package tests;
import junit.framework.Assert;

import org.junit.*;

import shapeclassifier.ShapeClassifier;

import static org.junit.Assert.*;

public class ShapeClassifierThreeWiseTest {

	ShapeClassifier c = new ShapeClassifier();

	@Test
	public void test_threewise1() {
	System.out.println("======================== Test Case threewise1 ========================\n");
	System.out.println("Input: [Line,Large,No,650]\n");
	System.out.println("Expected Output: [No: Wrong Even/Odd]\n");
	assertEquals("Check ", "No: Wrong Even/Odd", c.evaluateGuess("Line,Large,No,650"));
	}
	@Test
	public void test_threewise2() {
	System.out.println("======================== Test Case threewise2 ========================\n");
	System.out.println("Input: [Square,Small,No,6,68,18]\n");
	System.out.println("Expected Output: [No: Suggestion=Not A Triangle, Wrong Even/Odd]\n");
	assertEquals("Check ", "No: Suggestion=Not A Triangle, Wrong Even/Odd", c.evaluateGuess("Square,Small,No,6,68,18"));
	}
	@Test
	public void test_threewise3() {
	System.out.println("======================== Test Case threewise3 ========================\n");
	System.out.println("Input: [Isosceles,Small,Yes,1166,1556,1847]\n");
	System.out.println("Expected Output: [No: Suggestion=Scalene, Wrong Size]\n");
	assertEquals("Check ", "No: Suggestion=Scalene, Wrong Size", c.evaluateGuess("Isosceles,Small,Yes,1166,1556,1847"));
	}
	@Test
	public void test_threewise4() {
	System.out.println("======================== Test Case threewise4 ========================\n");
	System.out.println("Input: [Rectangle,Large,Yes,2797,3979,2797]\n");
	System.out.println("Expected Output: [No: Suggestion=Isosceles3, Wrong Even/Odd]\n");
	assertEquals("Check ", "No: Suggestion=Isosceles3, Wrong Even/Odd", c.evaluateGuess("Rectangle,Large,Yes,2797,3979,2797"));
	}
	@Test
	public void test_threewise5() {
	System.out.println("======================== Test Case threewise5 ========================\n");
	System.out.println("Input: [Scalene,Small,No,3885,1281,2535]\n");
	System.out.println("Expected Output: [No: Suggestion=Not A Triangle, Wrong Size]\n");
	assertEquals("Check ", "No: Suggestion=Not A Triangle, Wrong Size", c.evaluateGuess("Scalene,Small,No,3885,1281,2535"));
	}
	@Test
	public void test_threewise6() {
	System.out.println("======================== Test Case threewise6 ========================\n");
	System.out.println("Input: [Scalene,Large,Yes,11,39,39]\n");
	System.out.println("Expected Output: [Bad guess limit Exceeded]\n");
	assertEquals("Check ", "Bad guess limit Exceeded", c.evaluateGuess("Scalene,Large,Yes,11,39,39"));
	}
	@Test
	public void test_threewise7() {
	System.out.println("======================== Test Case threewise7 ========================\n");
	System.out.println("Input: [Circle,Large,No,15,5]\n");
	System.out.println("Expected Output: [No: Suggestion=Ellipse, Wrong Size]\n");
	assertEquals("Check ", "No: Suggestion=Ellipse, Wrong Size", c.evaluateGuess("Circle,Large,No,15,5"));
	}
	@Test
	public void test_threewise8() {
	System.out.println("======================== Test Case threewise8 ========================\n");
	System.out.println("Input: [Equilateral,Large,Yes,14,21,12,5]\n");
	System.out.println("Expected Output: [No: Suggestion=Not A Rectangle, Wrong Size]\n");
	assertEquals("Check ", "No: Suggestion=Not A Rectangle, Wrong Size", c.evaluateGuess("Equilateral,Large,Yes,14,21,12,5"));
	}
	@Test
	public void test_threewise9() {
	System.out.println("======================== Test Case threewise9 ========================\n");
	System.out.println("Input: [Circle,Small,Yes,13,13,13,13]\n");
	System.out.println("Expected Output: [No: Suggestion=Square, Wrong Even/Odd]\n");
	assertEquals("Check ", "No: Suggestion=Square, Wrong Even/Odd", c.evaluateGuess("Circle,Small,Yes,13,13,13,13"));
	}
	@Test
	public void test_threewise10() {
	System.out.println("======================== Test Case threewise10 ========================\n");
	System.out.println("Input: [Line,Large,Yes,31,31,31]\n");
	System.out.println("Expected Output: [Bad guess limit Exceeded]\n");
	assertEquals("Check ", "Bad guess limit Exceeded", c.evaluateGuess("Line,Large,Yes,31,31,31"));
	}
	@Test
	public void test_threewise11() {
	System.out.println("======================== Test Case threewise11 ========================\n");
	System.out.println("Input: [Ellipse,Small,No,367,367,576]\n");
	System.out.println("Expected Output: [Bad guess limit Exceeded]\n");
	assertEquals("Check ", "Bad guess limit Exceeded", c.evaluateGuess("Ellipse,Small,No,367,367,576"));
	}
	@Test
	public void test_threewise12() {
	System.out.println("======================== Test Case threewise12 ========================\n");
	System.out.println("Input: [Square,Large,Yes,5,5]\n");
	System.out.println("Expected Output: [Bad guess limit Exceeded]\n");
	assertEquals("Check ", "Bad guess limit Exceeded", c.evaluateGuess("Square,Large,Yes,5,5"));
	}
	@Test
	public void test_threewise13() {
	System.out.println("======================== Test Case threewise13 ========================\n");
	System.out.println("Input: [Equilateral,Small,No,1396,2030]\n");
	System.out.println("Expected Output: [Bad guess limit Exceeded]\n");
	assertEquals("Check ", "Bad guess limit Exceeded", c.evaluateGuess("Equilateral,Small,No,1396,2030"));
	}
	@Test
	public void test_threewise14() {
	System.out.println("======================== Test Case threewise14 ========================\n");
	System.out.println("Input: [Ellipse,Small,Yes,3,19,31]\n");
	System.out.println("Expected Output: [No: Suggestion=Not A Triangle, Wrong Even/Odd]\n");
	assertEquals("Check ", "No: Suggestion=Not A Triangle, Wrong Even/Odd", c.evaluateGuess("Ellipse,Small,Yes,3,19,31"));
	}
	@Test
	public void test_threewise15() {
	System.out.println("======================== Test Case threewise15 ========================\n");
	System.out.println("Input: [Isosceles,Small,No,1,35,1,35]\n");
	System.out.println("Expected Output: [No: Suggestion=Rectangle]\n");
	assertEquals("Check ", "No: Suggestion=Rectangle", c.evaluateGuess("Isosceles,Small,No,1,35,1,35"));
	}
	@Test
	public void test_threewise16() {
	System.out.println("======================== Test Case threewise16 ========================\n");
	System.out.println("Input: [Rectangle,Small,Yes,8]\n");
	System.out.println("Expected Output: [No: Suggestion=Line]\n");
	assertEquals("Check ", "No: Suggestion=Line", c.evaluateGuess("Rectangle,Small,Yes,8"));
	}
	@Test
	public void test_threewise17() {
	System.out.println("======================== Test Case threewise17 ========================\n");
	System.out.println("Input: [Isosceles,Large,No,16,20,16]\n");
	System.out.println("Expected Output: [Bad guess limit Exceeded]\n");
	assertEquals("Check ", "Bad guess limit Exceeded", c.evaluateGuess("Isosceles,Large,No,16,20,16"));
	}
	@Test
	public void test_threewise18() {
	System.out.println("======================== Test Case threewise18 ========================\n");
	System.out.println("Input: [Circle,Large,Yes,2612,637,1520]\n");
	System.out.println("Expected Output: [No: Suggestion=Not A Triangle]\n");
	assertEquals("Check ", "No: Suggestion=Not A Triangle", c.evaluateGuess("Circle,Large,Yes,2612,637,1520"));
	}
	@Test
	public void test_threewise19() {
	System.out.println("======================== Test Case threewise19 ========================\n");
	System.out.println("Input: [Rectangle,Large,No,679,2088,2998]\n");
	System.out.println("Expected Output: [No: Suggestion=Not A Triangle, Wrong Even/Odd]\n");
	assertEquals("Check ", "No: Suggestion=Not A Triangle, Wrong Even/Odd", c.evaluateGuess("Rectangle,Large,No,679,2088,2998"));
	}
	@Test
	public void test_threewise20() {
	System.out.println("======================== Test Case threewise20 ========================\n");
	System.out.println("Input: [Line,Small,Yes,2417,3913,267]\n");
	System.out.println("Expected Output: [Bad guess limit Exceeded]\n");
	assertEquals("Check ", "Bad guess limit Exceeded", c.evaluateGuess("Line,Small,Yes,2417,3913,267"));
	}
	@Test
	public void test_threewise21() {
	System.out.println("======================== Test Case threewise21 ========================\n");
	System.out.println("Input: [Ellipse,Large,Yes,553,1689,1689]\n");
	System.out.println("Expected Output: [No: Suggestion=Isosceles2, Wrong Even/Odd]\n");
	assertEquals("Check ", "No: Suggestion=Isosceles2, Wrong Even/Odd", c.evaluateGuess("Ellipse,Large,Yes,553,1689,1689"));
	}
	@Test
	public void test_threewise22() {
	System.out.println("======================== Test Case threewise22 ========================\n");
	System.out.println("Input: [Scalene,Large,Yes,3868,3868,3868,3868]\n");
	System.out.println("Expected Output: [No: Suggestion=Square]\n");
	assertEquals("Check ", "No: Suggestion=Square", c.evaluateGuess("Scalene,Large,Yes,3868,3868,3868,3868"));
	}
	@Test
	public void test_threewise23() {
	System.out.println("======================== Test Case threewise23 ========================\n");
	System.out.println("Input: [Equilateral,Large,Yes,1947,1947,3245]\n");
	System.out.println("Expected Output: [No: Suggestion=Isosceles1, Wrong Even/Odd]\n");
	assertEquals("Check ", "No: Suggestion=Isosceles1, Wrong Even/Odd", c.evaluateGuess("Equilateral,Large,Yes,1947,1947,3245"));
	}
	@Test
	public void test_threewise24() {
	System.out.println("======================== Test Case threewise24 ========================\n");
	System.out.println("Input: [Square,Large,No,896,896,896]\n");
	System.out.println("Expected Output: [No: Suggestion=Equilateral, Wrong Even/Odd]\n");
	assertEquals("Check ", "No: Suggestion=Equilateral, Wrong Even/Odd", c.evaluateGuess("Square,Large,No,896,896,896"));
	}
	@Test
	public void test_threewise25() {
	System.out.println("======================== Test Case threewise25 ========================\n");
	System.out.println("Input: [Equilateral,Small,No,3,3]\n");
	System.out.println("Expected Output: [No: Suggestion=Circle]\n");
	assertEquals("Check ", "No: Suggestion=Circle", c.evaluateGuess("Equilateral,Small,No,3,3"));
	}
	@Test
	public void test_threewise26() {
	System.out.println("======================== Test Case threewise26 ========================\n");
	System.out.println("Input: [Square,Small,No,999,525,1041]\n");
	System.out.println("Expected Output: [No: Suggestion=Scalene, Wrong Size]\n");
	assertEquals("Check ", "No: Suggestion=Scalene, Wrong Size", c.evaluateGuess("Square,Small,No,999,525,1041"));
	}
	@Test
	public void test_threewise27() {
	System.out.println("======================== Test Case threewise27 ========================\n");
	System.out.println("Input: [Rectangle,Small,No,293,2321,2203,2771]\n");
	System.out.println("Expected Output: [No: Suggestion=Not A Rectangle, Wrong Size]\n");
	assertEquals("Check ", "No: Suggestion=Not A Rectangle, Wrong Size", c.evaluateGuess("Rectangle,Small,No,293,2321,2203,2771"));
	}
	@Test
	public void test_threewise28() {
	System.out.println("======================== Test Case threewise28 ========================\n");
	System.out.println("Input: [Scalene,Large,No,415,720,415,720]\n");
	System.out.println("Expected Output: [No: Suggestion=Rectangle, Wrong Even/Odd]\n");
	assertEquals("Check ", "No: Suggestion=Rectangle, Wrong Even/Odd", c.evaluateGuess("Scalene,Large,No,415,720,415,720"));
	}
	@Test
	public void test_threewise29() {
	System.out.println("======================== Test Case threewise29 ========================\n");
	System.out.println("Input: [Circle,Small,Yes,3,2,2]\n");
	System.out.println("Expected Output: [No: Suggestion=Isosceles2]\n");
	assertEquals("Check ", "No: Suggestion=Isosceles2", c.evaluateGuess("Circle,Small,Yes,3,2,2"));
	}
	@Test
	public void test_threewise30() {
	System.out.println("======================== Test Case threewise30 ========================\n");
	System.out.println("Input: [Ellipse,Large,No,24,9,28]\n");
	System.out.println("Expected Output: [Bad guess limit Exceeded]\n");
	assertEquals("Check ", "Bad guess limit Exceeded", c.evaluateGuess("Ellipse,Large,No,24,9,28"));
	}
	@Test
	public void test_threewise31() {
	System.out.println("======================== Test Case threewise31 ========================\n");
	System.out.println("Input: [Line,Small,No,23,34,23]\n");
	System.out.println("Expected Output: [No: Suggestion=Isosceles3, Wrong Even/Odd]\n");
	assertEquals("Check ", "No: Suggestion=Isosceles3, Wrong Even/Odd", c.evaluateGuess("Line,Small,No,23,34,23"));
	}
	@Test
	public void test_threewise32() {
	System.out.println("======================== Test Case threewise32 ========================\n");
	System.out.println("Input: [Isosceles,Large,No,1177,1177]\n");
	System.out.println("Expected Output: [No: Suggestion=Circle]\n");
	assertEquals("Check ", "No: Suggestion=Circle", c.evaluateGuess("Isosceles,Large,No,1177,1177"));
	}
	@Test
	public void test_threewise33() {
	System.out.println("======================== Test Case threewise33 ========================\n");
	System.out.println("Input: [Scalene,Small,No,18,18,18]\n");
	System.out.println("Expected Output: [No: Suggestion=Equilateral, Wrong Even/Odd]\n");
	assertEquals("Check ", "No: Suggestion=Equilateral, Wrong Even/Odd", c.evaluateGuess("Scalene,Small,No,18,18,18"));
	}
	@Test
	public void test_threewise34() {
	System.out.println("======================== Test Case threewise34 ========================\n");
	System.out.println("Input: [Isosceles,Small,Yes,23,23,15]\n");
	System.out.println("Expected Output: [No: Suggestion=Isosceles1, Wrong Even/Odd]\n");
	assertEquals("Check ", "No: Suggestion=Isosceles1, Wrong Even/Odd", c.evaluateGuess("Isosceles,Small,Yes,23,23,15"));
	}
	@Test
	public void test_threewise35() {
	System.out.println("======================== Test Case threewise35 ========================\n");
	System.out.println("Input: [Square,Small,Yes,1949,2027]\n");
	System.out.println("Expected Output: [Bad guess limit Exceeded]\n");
	assertEquals("Check ", "Bad guess limit Exceeded", c.evaluateGuess("Square,Small,Yes,1949,2027"));
	}
	@Test
	public void test_threewise36() {
	System.out.println("======================== Test Case threewise36 ========================\n");
	System.out.println("Input: [Circle,Small,No,2845]\n");
	System.out.println("Expected Output: [No: Suggestion=Line, Wrong Size]\n");
	assertEquals("Check ", "No: Suggestion=Line, Wrong Size", c.evaluateGuess("Circle,Small,No,2845"));
	}
	@Test
	public void test_threewise37() {
	System.out.println("======================== Test Case threewise37 ========================\n");
	System.out.println("Input: [Equilateral,Large,No,15,39,21]\n");
	System.out.println("Expected Output: [No: Suggestion=Not A Triangle, Wrong Size]\n");
	assertEquals("Check ", "No: Suggestion=Not A Triangle, Wrong Size", c.evaluateGuess("Equilateral,Large,No,15,39,21"));
	}
	@Test
	public void test_threewise38() {
	System.out.println("======================== Test Case threewise38 ========================\n");
	System.out.println("Input: [Rectangle,Large,No,45,15,23]\n");
	System.out.println("Expected Output: [No: Suggestion=Not A Triangle, Wrong Size]\n");
	assertEquals("Check ", "No: Suggestion=Not A Triangle, Wrong Size", c.evaluateGuess("Rectangle,Large,No,45,15,23"));
	}
	@Test
	public void test_threewise39() {
	System.out.println("======================== Test Case threewise39 ========================\n");
	System.out.println("Input: [Line,Large,No,3655,3655,3655,3655]\n");
	System.out.println("Expected Output: [No: Suggestion=Square]\n");
	assertEquals("Check ", "No: Suggestion=Square", c.evaluateGuess("Line,Large,No,3655,3655,3655,3655"));
	}
	@Test
	public void test_threewise40() {
	System.out.println("======================== Test Case threewise40 ========================\n");
	System.out.println("Input: [Ellipse,Large,Yes,0,3]\n");
	System.out.println("Expected Output: [No: Wrong Size]\n");
	assertEquals("Check ", "No: Wrong Size", c.evaluateGuess("Ellipse,Large,Yes,0,3"));
	}
	@Test
	public void test_threewise41() {
	System.out.println("======================== Test Case threewise41 ========================\n");
	System.out.println("Input: [Equilateral,Large,Yes,4,4,4,4]\n");
	System.out.println("Expected Output: [No: Suggestion=Rectangle, Wrong Size]\n");
	assertEquals("Check ", "No: Suggestion=Rectangle, Wrong Size", c.evaluateGuess("Equilateral,Large,Yes,4,4,4,4"));
	}
	@Test
	public void test_threewise42() {
	System.out.println("======================== Test Case threewise42 ========================\n");
	System.out.println("Input: [Square,Large,Yes,2,40,43]\n");
	System.out.println("Expected Output: [No: Suggestion=Not A Triangle, Wrong Size]\n");
	assertEquals("Check ", "No: Suggestion=Not A Triangle, Wrong Size", c.evaluateGuess("Square,Large,Yes,2,40,43"));
	}
	@Test
	public void test_threewise43() {
	System.out.println("======================== Test Case threewise43 ========================\n");
	System.out.println("Input: [Isosceles,Small,Yes,3235,3522,968,1137]\n");
	System.out.println("Expected Output: [No: Suggestion=Not A Rectangle, Wrong Size]\n");
	assertEquals("Check ", "No: Suggestion=Not A Rectangle, Wrong Size", c.evaluateGuess("Isosceles,Small,Yes,3235,3522,968,1137"));
	}
	@Test
	public void test_threewise44() {
	System.out.println("======================== Test Case threewise44 ========================\n");
	System.out.println("Input: [Square,Small,No,2312,3537,3537]\n");
	System.out.println("Expected Output: [Bad guess limit Exceeded]\n");
	assertEquals("Check ", "Bad guess limit Exceeded", c.evaluateGuess("Square,Small,No,2312,3537,3537"));
	}
	@Test
	public void test_threewise45() {
	System.out.println("======================== Test Case threewise45 ========================\n");
	System.out.println("Input: [Line,Small,Yes,3550,3550]\n");
	System.out.println("Expected Output: [No: Suggestion=Circle, Wrong Size]\n");
	assertEquals("Check ", "No: Suggestion=Circle, Wrong Size", c.evaluateGuess("Line,Small,Yes,3550,3550"));
	}
	@Test
	public void test_threewise46() {
	System.out.println("======================== Test Case threewise46 ========================\n");
	System.out.println("Input: [Equilateral,Small,Yes,17,9,17]\n");
	System.out.println("Expected Output: [No: Suggestion=Isosceles3, Wrong Even/Odd]\n");
	assertEquals("Check ", "No: Suggestion=Isosceles3, Wrong Even/Odd", c.evaluateGuess("Equilateral,Small,Yes,17,9,17"));
	}
	@Test
	public void test_threewise47() {
	System.out.println("======================== Test Case threewise47 ========================\n");
	System.out.println("Input: [Scalene,Small,Yes,3833,3133,3833,3133]\n");
	System.out.println("Expected Output: [Bad guess limit Exceeded]\n");
	assertEquals("Check ", "Bad guess limit Exceeded", c.evaluateGuess("Scalene,Small,Yes,3833,3133,3833,3133"));
	}
	@Test
	public void test_threewise48() {
	System.out.println("======================== Test Case threewise48 ========================\n");
	System.out.println("Input: [Ellipse,Large,No,645,2216,1397]\n");
	System.out.println("Expected Output: [No: Suggestion=Not A Triangle, Wrong Even/Odd]\n");
	assertEquals("Check ", "No: Suggestion=Not A Triangle, Wrong Even/Odd", c.evaluateGuess("Ellipse,Large,No,645,2216,1397"));
	}
	@Test
	public void test_threewise49() {
	System.out.println("======================== Test Case threewise49 ========================\n");
	System.out.println("Input: [Ellipse,Large,No,29,1569,1923,1695]\n");
	System.out.println("Expected Output: [No: Suggestion=Not A Rectangle]\n");
	assertEquals("Check ", "No: Suggestion=Not A Rectangle", c.evaluateGuess("Ellipse,Large,No,29,1569,1923,1695"));
	}
	@Test
	public void test_threewise50() {
	System.out.println("======================== Test Case threewise50 ========================\n");
	System.out.println("Input: [Circle,Large,No,45,45,2]\n");
	System.out.println("Expected Output: [Bad guess limit Exceeded]\n");
	assertEquals("Check ", "Bad guess limit Exceeded", c.evaluateGuess("Circle,Large,No,45,45,2"));
	}
	@Test
	public void test_threewise51() {
	System.out.println("======================== Test Case threewise51 ========================\n");
	System.out.println("Input: [Rectangle,Small,Yes,1667,1667,1667]\n");
	System.out.println("Expected Output: [Bad guess limit Exceeded]\n");
	assertEquals("Check ", "Bad guess limit Exceeded", c.evaluateGuess("Rectangle,Small,Yes,1667,1667,1667"));
	}
	@Test
	public void test_threewise52() {
	System.out.println("======================== Test Case threewise52 ========================\n");
	System.out.println("Input: [Isosceles,Small,No,20,20,20,20]\n");
	System.out.println("Expected Output: [No: Suggestion=Square, Wrong Even/Odd]\n");
	assertEquals("Check ", "No: Suggestion=Square, Wrong Even/Odd", c.evaluateGuess("Isosceles,Small,No,20,20,20,20"));
	}
	@Test
	public void test_threewise53() {
	System.out.println("======================== Test Case threewise53 ========================\n");
	System.out.println("Input: [Scalene,Large,Yes,1921,281,1843]\n");
	System.out.println("Expected Output: [No: Wrong Even/Odd]\n");
	assertEquals("Check ", "No: Wrong Even/Odd", c.evaluateGuess("Scalene,Large,Yes,1921,281,1843"));
	}
	@Test
	public void test_threewise54() {
	System.out.println("======================== Test Case threewise54 ========================\n");
	System.out.println("Input: [Isosceles,Small,Yes,46,14,31]\n");
	System.out.println("Expected Output: [No: Suggestion=Not A Triangle]\n");
	assertEquals("Check ", "No: Suggestion=Not A Triangle", c.evaluateGuess("Isosceles,Small,Yes,46,14,31"));
	}
	@Test
	public void test_threewise55() {
	System.out.println("======================== Test Case threewise55 ========================\n");
	System.out.println("Input: [Square,Large,Yes,49]\n");
	System.out.println("Expected Output: [Bad guess limit Exceeded]\n");
	assertEquals("Check ", "Bad guess limit Exceeded", c.evaluateGuess("Square,Large,Yes,49"));
	}
	@Test
	public void test_threewise56() {
	System.out.println("======================== Test Case threewise56 ========================\n");
	System.out.println("Input: [Isosceles,Large,Yes,2041,1727,4061]\n");
	System.out.println("Expected Output: [No: Suggestion=Not A Triangle, Wrong Even/Odd]\n");
	assertEquals("Check ", "No: Suggestion=Not A Triangle, Wrong Even/Odd", c.evaluateGuess("Isosceles,Large,Yes,2041,1727,4061"));
	}
	@Test
	public void test_threewise57() {
	System.out.println("======================== Test Case threewise57 ========================\n");
	System.out.println("Input: [Line,Small,No,5,5,11]\n");
	System.out.println("Expected Output: [No: Suggestion=Not A Triangle]\n");
	assertEquals("Check ", "No: Suggestion=Not A Triangle", c.evaluateGuess("Line,Small,No,5,5,11"));
	}
	@Test
	public void test_threewise58() {
	System.out.println("======================== Test Case threewise58 ========================\n");
	System.out.println("Input: [Ellipse,Small,No,3130,3029,3130]\n");
	System.out.println("Expected Output: [Bad guess limit Exceeded]\n");
	assertEquals("Check ", "Bad guess limit Exceeded", c.evaluateGuess("Ellipse,Small,No,3130,3029,3130"));
	}
	@Test
	public void test_threewise59() {
	System.out.println("======================== Test Case threewise59 ========================\n");
	System.out.println("Input: [Circle,Small,No,5,13,9,11]\n");
	System.out.println("Expected Output: [No: Suggestion=Not A Rectangle]\n");
	assertEquals("Check ", "No: Suggestion=Not A Rectangle", c.evaluateGuess("Circle,Small,No,5,13,9,11"));
	}
	@Test
	public void test_threewise60() {
	System.out.println("======================== Test Case threewise60 ========================\n");
	System.out.println("Input: [Line,Large,No,3,7,7]\n");
	System.out.println("Expected Output: [No: Suggestion=Isosceles2, Wrong Size]\n");
	assertEquals("Check ", "No: Suggestion=Isosceles2, Wrong Size", c.evaluateGuess("Line,Large,No,3,7,7"));
	}
	@Test
	public void test_threewise61() {
	System.out.println("======================== Test Case threewise61 ========================\n");
	System.out.println("Input: [Circle,Small,Yes,11,9,15]\n");
	System.out.println("Expected Output: [No: Suggestion=Scalene, Wrong Even/Odd]\n");
	assertEquals("Check ", "No: Suggestion=Scalene, Wrong Even/Odd", c.evaluateGuess("Circle,Small,Yes,11,9,15"));
	}
	@Test
	public void test_threewise62() {
	System.out.println("======================== Test Case threewise62 ========================\n");
	System.out.println("Input: [Circle,Large,Yes,4,35,28]\n");
	System.out.println("Expected Output: [No: Suggestion=Not A Triangle, Wrong Size]\n");
	assertEquals("Check ", "No: Suggestion=Not A Triangle, Wrong Size", c.evaluateGuess("Circle,Large,Yes,4,35,28"));
	}
	@Test
	public void test_threewise63() {
	System.out.println("======================== Test Case threewise63 ========================\n");
	System.out.println("Input: [Rectangle,Small,No,8,8]\n");
	System.out.println("Expected Output: [No: Suggestion=Circle, Wrong Even/Odd]\n");
	assertEquals("Check ", "No: Suggestion=Circle, Wrong Even/Odd", c.evaluateGuess("Rectangle,Small,No,8,8"));
	}
	@Test
	public void test_threewise64() {
	System.out.println("======================== Test Case threewise64 ========================\n");
	System.out.println("Input: [Ellipse,Small,No,8,23,8,23]\n");
	System.out.println("Expected Output: [No: Suggestion=Rectangle, Wrong Even/Odd]\n");
	assertEquals("Check ", "No: Suggestion=Rectangle, Wrong Even/Odd", c.evaluateGuess("Ellipse,Small,No,8,23,8,23"));
	}
	@Test
	public void test_threewise65() {
	System.out.println("======================== Test Case threewise65 ========================\n");
	System.out.println("Input: [Ellipse,Large,No,34]\n");
	System.out.println("Expected Output: [Bad guess limit Exceeded]\n");
	assertEquals("Check ", "Bad guess limit Exceeded", c.evaluateGuess("Ellipse,Large,No,34"));
	}
	@Test
	public void test_threewise66() {
	System.out.println("======================== Test Case threewise66 ========================\n");
	System.out.println("Input: [Scalene,Large,Yes,75,2757]\n");
	System.out.println("Expected Output: [No: Suggestion=Ellipse, Wrong Even/Odd]\n");
	assertEquals("Check ", "No: Suggestion=Ellipse, Wrong Even/Odd", c.evaluateGuess("Scalene,Large,Yes,75,2757"));
	}
	@Test
	public void test_threewise67() {
	System.out.println("======================== Test Case threewise67 ========================\n");
	System.out.println("Input: [Isosceles,Small,No,2691,3643,3643]\n");
	System.out.println("Expected Output: [No: Suggestion=Isosceles2, Wrong Size]\n");
	assertEquals("Check ", "No: Suggestion=Isosceles2, Wrong Size", c.evaluateGuess("Isosceles,Small,No,2691,3643,3643"));
	}
	@Test
	public void test_threewise68() {
	System.out.println("======================== Test Case threewise68 ========================\n");
	System.out.println("Input: [Circle,Small,Yes,102,1451,3928]\n");
	System.out.println("Expected Output: [No: Suggestion=Not A Triangle, Wrong Size]\n");
	assertEquals("Check ", "No: Suggestion=Not A Triangle, Wrong Size", c.evaluateGuess("Circle,Small,Yes,102,1451,3928"));
	}
	@Test
	public void test_threewise69() {
	System.out.println("======================== Test Case threewise69 ========================\n");
	System.out.println("Input: [Square,Large,No,20,7,11]\n");
	System.out.println("Expected Output: [Bad guess limit Exceeded]\n");
	assertEquals("Check ", "Bad guess limit Exceeded", c.evaluateGuess("Square,Large,No,20,7,11"));
	}
	@Test
	public void test_threewise70() {
	System.out.println("======================== Test Case threewise70 ========================\n");
	System.out.println("Input: [Equilateral,Large,No,3461,3461,3461]\n");
	System.out.println("Expected Output: [Yes: ]\n");
	assertEquals("Check ", "Yes: ", c.evaluateGuess("Equilateral,Large,No,3461,3461,3461"));
	}
	@Test
	public void test_threewise71() {
	System.out.println("======================== Test Case threewise71 ========================\n");
	System.out.println("Input: [Scalene,Large,Yes,3474,3474,12]\n");
	System.out.println("Expected Output: [No: Suggestion=Isosceles1]\n");
	assertEquals("Check ", "No: Suggestion=Isosceles1", c.evaluateGuess("Scalene,Large,Yes,3474,3474,12"));
	}
	@Test
	public void test_threewise72() {
	System.out.println("======================== Test Case threewise72 ========================\n");
	System.out.println("Input: [Equilateral,Small,No,1605,1605,1605,1605]\n");
	System.out.println("Expected Output: [No: Suggestion=Square, Wrong Size]\n");
	assertEquals("Check ", "No: Suggestion=Square, Wrong Size", c.evaluateGuess("Equilateral,Small,No,1605,1605,1605,1605"));
	}
	@Test
	public void test_threewise73() {
	System.out.println("======================== Test Case threewise73 ========================\n");
	System.out.println("Input: [Square,Large,No,45,5,45]\n");
	System.out.println("Expected Output: [No: Suggestion=Isosceles3, Wrong Size]\n");
	assertEquals("Check ", "No: Suggestion=Isosceles3, Wrong Size", c.evaluateGuess("Square,Large,No,45,5,45"));
	}
	@Test
	public void test_threewise74() {
	System.out.println("======================== Test Case threewise74 ========================\n");
	System.out.println("Input: [Rectangle,Large,No,2279,2345,2279,2345]\n");
	System.out.println("Expected Output: [Yes: ]\n");
	assertEquals("Check ", "Yes: ", c.evaluateGuess("Rectangle,Large,No,2279,2345,2279,2345"));
	}
	@Test
	public void test_threewise75() {
	System.out.println("======================== Test Case threewise75 ========================\n");
	System.out.println("Input: [Square,Large,No,25,4,21,18]\n");
	System.out.println("Expected Output: [Bad guess limit Exceeded]\n");
	assertEquals("Check ", "Bad guess limit Exceeded", c.evaluateGuess("Square,Large,No,25,4,21,18"));
	}
	@Test
	public void test_threewise76() {
	System.out.println("======================== Test Case threewise76 ========================\n");
	System.out.println("Input: [Rectangle,Large,Yes,13,13,13,13]\n");
	System.out.println("Expected Output: [Bad guess limit Exceeded]\n");
	assertEquals("Check ", "Bad guess limit Exceeded", c.evaluateGuess("Rectangle,Large,Yes,13,13,13,13"));
	}
	@Test
	public void test_threewise77() {
	System.out.println("======================== Test Case threewise77 ========================\n");
	System.out.println("Input: [Scalene,Large,No,3684,3684]\n");
	System.out.println("Expected Output: [No: Suggestion=Circle, Wrong Even/Odd]\n");
	assertEquals("Check ", "No: Suggestion=Circle, Wrong Even/Odd", c.evaluateGuess("Scalene,Large,No,3684,3684"));
	}
	@Test
	public void test_threewise78() {
	System.out.println("======================== Test Case threewise78 ========================\n");
	System.out.println("Input: [Line,Small,No,7,7,9]\n");
	System.out.println("Expected Output: [No: Suggestion=Isosceles1]\n");
	assertEquals("Check ", "No: Suggestion=Isosceles1", c.evaluateGuess("Line,Small,No,7,7,9"));
	}
	@Test
	public void test_threewise79() {
	System.out.println("======================== Test Case threewise79 ========================\n");
	System.out.println("Input: [Isosceles,Small,Yes,1346]\n");
	System.out.println("Expected Output: [No: Suggestion=Line, Wrong Size]\n");
	assertEquals("Check ", "No: Suggestion=Line, Wrong Size", c.evaluateGuess("Isosceles,Small,Yes,1346"));
	}
	@Test
	public void test_threewise80() {
	System.out.println("======================== Test Case threewise80 ========================\n");
	System.out.println("Input: [Line,Large,Yes,3771,487,2155]\n");
	System.out.println("Expected Output: [No: Suggestion=Not A Triangle, Wrong Even/Odd]\n");
	assertEquals("Check ", "No: Suggestion=Not A Triangle, Wrong Even/Odd", c.evaluateGuess("Line,Large,Yes,3771,487,2155"));
	}
	@Test
	public void test_threewise81() {
	System.out.println("======================== Test Case threewise81 ========================\n");
	System.out.println("Input: [Ellipse,Large,Yes,24,24,24]\n");
	System.out.println("Expected Output: [No: Suggestion=Equilateral, Wrong Size]\n");
	assertEquals("Check ", "No: Suggestion=Equilateral, Wrong Size", c.evaluateGuess("Ellipse,Large,Yes,24,24,24"));
	}
	@Test
	public void test_threewise82() {
	System.out.println("======================== Test Case threewise82 ========================\n");
	System.out.println("Input: [Rectangle,Small,Yes,1,1]\n");
	System.out.println("Expected Output: [No: Suggestion=Ellipse, Wrong Even/Odd]\n");
	assertEquals("Check ", "No: Suggestion=Ellipse, Wrong Even/Odd", c.evaluateGuess("Rectangle,Small,Yes,1,1"));
	}
	@Test
	public void test_threewise83() {
	System.out.println("======================== Test Case threewise83 ========================\n");
	System.out.println("Input: [Isosceles,Small,No,2,16,14]\n");
	System.out.println("Expected Output: [No: Suggestion=Not A Triangle, Wrong Even/Odd]\n");
	assertEquals("Check ", "No: Suggestion=Not A Triangle, Wrong Even/Odd", c.evaluateGuess("Isosceles,Small,No,2,16,14"));
	}
	@Test
	public void test_threewise84() {
	System.out.println("======================== Test Case threewise84 ========================\n");
	System.out.println("Input: [Rectangle,Small,No,13,21,29]\n");
	System.out.println("Expected Output: [No: Suggestion=Scalene]\n");
	assertEquals("Check ", "No: Suggestion=Scalene", c.evaluateGuess("Rectangle,Small,No,13,21,29"));
	}
	@Test
	public void test_threewise85() {
	System.out.println("======================== Test Case threewise85 ========================\n");
	System.out.println("Input: [Equilateral,Large,No,14,36,36]\n");
	System.out.println("Expected Output: [Bad guess limit Exceeded]\n");
	assertEquals("Check ", "Bad guess limit Exceeded", c.evaluateGuess("Equilateral,Large,No,14,36,36"));
	}
	@Test
	public void test_threewise86() {
	System.out.println("======================== Test Case threewise86 ========================\n");
	System.out.println("Input: [Ellipse,Large,No,7,7,7,7]\n");
	System.out.println("Expected Output: [No: Suggestion=Square, Wrong Size]\n");
	assertEquals("Check ", "No: Suggestion=Square, Wrong Size", c.evaluateGuess("Ellipse,Large,No,7,7,7,7"));
	}
	@Test
	public void test_threewise87() {
	System.out.println("======================== Test Case threewise87 ========================\n");
	System.out.println("Input: [Circle,Large,Yes,3080,2622,3080]\n");
	System.out.println("Expected Output: [No: Suggestion=Isosceles3]\n");
	assertEquals("Check ", "No: Suggestion=Isosceles3", c.evaluateGuess("Circle,Large,Yes,3080,2622,3080"));
	}
	@Test
	public void test_threewise88() {
	System.out.println("======================== Test Case threewise88 ========================\n");
	System.out.println("Input: [Line,Small,No,3637,1391,3639,3923]\n");
	System.out.println("Expected Output: [No: Suggestion=Not A Rectangle, Wrong Size]\n");
	assertEquals("Check ", "No: Suggestion=Not A Rectangle, Wrong Size", c.evaluateGuess("Line,Small,No,3637,1391,3639,3923"));
	}
	@Test
	public void test_threewise89() {
	System.out.println("======================== Test Case threewise89 ========================\n");
	System.out.println("Input: [Line,Large,No,1574,2508,1574,2508]\n");
	System.out.println("Expected Output: [No: Suggestion=Rectangle, Wrong Even/Odd]\n");
	assertEquals("Check ", "No: Suggestion=Rectangle, Wrong Even/Odd", c.evaluateGuess("Line,Large,No,1574,2508,1574,2508"));
	}
	@Test
	public void test_threewise90() {
	System.out.println("======================== Test Case threewise90 ========================\n");
	System.out.println("Input: [Scalene,Large,No,29,12,26,15]\n");
	System.out.println("Expected Output: [Bad guess limit Exceeded]\n");
	assertEquals("Check ", "Bad guess limit Exceeded", c.evaluateGuess("Scalene,Large,No,29,12,26,15"));
	}
	@Test
	public void test_threewise91() {
	System.out.println("======================== Test Case threewise91 ========================\n");
	System.out.println("Input: [Equilateral,Large,Yes,2041,3768,3898]\n");
	System.out.println("Expected Output: [No: Suggestion=Scalene]\n");
	assertEquals("Check ", "No: Suggestion=Scalene", c.evaluateGuess("Equilateral,Large,Yes,2041,3768,3898"));
	}
	@Test
	public void test_threewise92() {
	System.out.println("======================== Test Case threewise92 ========================\n");
	System.out.println("Input: [Rectangle,Large,Yes,15,18,1]\n");
	System.out.println("Expected Output: [No: Suggestion=Not A Triangle, Wrong Size]\n");
	assertEquals("Check ", "No: Suggestion=Not A Triangle, Wrong Size", c.evaluateGuess("Rectangle,Large,Yes,15,18,1"));
	}
	@Test
	public void test_threewise93() {
	System.out.println("======================== Test Case threewise93 ========================\n");
	System.out.println("Input: [Equilateral,Large,Yes,2047,374,1605]\n");
	System.out.println("Expected Output: [No: Suggestion=Not A Triangle]\n");
	assertEquals("Check ", "No: Suggestion=Not A Triangle", c.evaluateGuess("Equilateral,Large,Yes,2047,374,1605"));
	}
	@Test
	public void test_threewise94() {
	System.out.println("======================== Test Case threewise94 ========================\n");
	System.out.println("Input: [Scalene,Large,No,797,1593,3586]\n");
	System.out.println("Expected Output: [No: Suggestion=Not A Triangle, Wrong Even/Odd]\n");
	assertEquals("Check ", "No: Suggestion=Not A Triangle, Wrong Even/Odd", c.evaluateGuess("Scalene,Large,No,797,1593,3586"));
	}
	@Test
	public void test_threewise95() {
	System.out.println("======================== Test Case threewise95 ========================\n");
	System.out.println("Input: [Isosceles,Small,Yes,1339,129]\n");
	System.out.println("Expected Output: [Bad guess limit Exceeded]\n");
	assertEquals("Check ", "Bad guess limit Exceeded", c.evaluateGuess("Isosceles,Small,Yes,1339,129"));
	}
	@Test
	public void test_threewise96() {
	System.out.println("======================== Test Case threewise96 ========================\n");
	System.out.println("Input: [Square,Small,Yes,2619,2619,2743]\n");
	System.out.println("Expected Output: [Bad guess limit Exceeded]\n");
	assertEquals("Check ", "Bad guess limit Exceeded", c.evaluateGuess("Square,Small,Yes,2619,2619,2743"));
	}
	@Test
	public void test_threewise97() {
	System.out.println("======================== Test Case threewise97 ========================\n");
	System.out.println("Input: [Equilateral,Small,Yes,71]\n");
	System.out.println("Expected Output: [No: Suggestion=Line, Wrong Even/Odd]\n");
	assertEquals("Check ", "No: Suggestion=Line, Wrong Even/Odd", c.evaluateGuess("Equilateral,Small,Yes,71"));
	}
	@Test
	public void test_threewise98() {
	System.out.println("======================== Test Case threewise98 ========================\n");
	System.out.println("Input: [Isosceles,Large,No,1428,1428,1428]\n");
	System.out.println("Expected Output: [No: Suggestion=Equilateral, Wrong Even/Odd]\n");
	assertEquals("Check ", "No: Suggestion=Equilateral, Wrong Even/Odd", c.evaluateGuess("Isosceles,Large,No,1428,1428,1428"));
	}
	@Test
	public void test_threewise99() {
	System.out.println("======================== Test Case threewise99 ========================\n");
	System.out.println("Input: [Circle,Small,No,13,13]\n");
	System.out.println("Expected Output: [Yes: ]\n");
	assertEquals("Check ", "Yes: ", c.evaluateGuess("Circle,Small,No,13,13"));
	}
	@Test
	public void test_threewise100() {
	System.out.println("======================== Test Case threewise100 ========================\n");
	System.out.println("Input: [Circle,Small,No,3486,2518,3486,2518]\n");
	System.out.println("Expected Output: [Bad guess limit Exceeded]\n");
	assertEquals("Check ", "Bad guess limit Exceeded", c.evaluateGuess("Circle,Small,No,3486,2518,3486,2518"));
	}
	@Test
	public void test_threewise101() {
	System.out.println("======================== Test Case threewise101 ========================\n");
	System.out.println("Input: [Scalene,Small,Yes,9,3,9]\n");
	System.out.println("Expected Output: [No: Suggestion=Isosceles3, Wrong Even/Odd]\n");
	assertEquals("Check ", "No: Suggestion=Isosceles3, Wrong Even/Odd", c.evaluateGuess("Scalene,Small,Yes,9,3,9"));
	}
	@Test
	public void test_threewise102() {
	System.out.println("======================== Test Case threewise102 ========================\n");
	System.out.println("Input: [Line,Small,No,215,405]\n");
	System.out.println("Expected Output: [No: Suggestion=Ellipse, Wrong Size]\n");
	assertEquals("Check ", "No: Suggestion=Ellipse, Wrong Size", c.evaluateGuess("Line,Small,No,215,405"));
	}
	@Test
	public void test_threewise103() {
	System.out.println("======================== Test Case threewise103 ========================\n");
	System.out.println("Input: [Rectangle,Small,No,4064,4064,4064,4064]\n");
	System.out.println("Expected Output: [Bad guess limit Exceeded]\n");
	assertEquals("Check ", "Bad guess limit Exceeded", c.evaluateGuess("Rectangle,Small,No,4064,4064,4064,4064"));
	}
	@Test
	public void test_threewise104() {
	System.out.println("======================== Test Case threewise104 ========================\n");
	System.out.println("Input: [Square,Small,Yes,11,11,11]\n");
	System.out.println("Expected Output: [No: Suggestion=Equilateral, Wrong Even/Odd]\n");
	assertEquals("Check ", "No: Suggestion=Equilateral, Wrong Even/Odd", c.evaluateGuess("Square,Small,Yes,11,11,11"));
	}
	@Test
	public void test_threewise105() {
	System.out.println("======================== Test Case threewise105 ========================\n");
	System.out.println("Input: [Ellipse,Small,No,21,13,3]\n");
	System.out.println("Expected Output: [No: Suggestion=Not A Triangle]\n");
	assertEquals("Check ", "No: Suggestion=Not A Triangle", c.evaluateGuess("Ellipse,Small,No,21,13,3"));
	}
	@Test
	public void test_threewise106() {
	System.out.println("======================== Test Case threewise106 ========================\n");
	System.out.println("Input: [Scalene,Large,No,36]\n");
	System.out.println("Expected Output: [Bad guess limit Exceeded]\n");
	assertEquals("Check ", "Bad guess limit Exceeded", c.evaluateGuess("Scalene,Large,No,36"));
	}
	@Test
	public void test_threewise107() {
	System.out.println("======================== Test Case threewise107 ========================\n");
	System.out.println("Input: [Rectangle,Large,Yes,1989,1989,3351]\n");
	System.out.println("Expected Output: [No: Suggestion=Isosceles1, Wrong Even/Odd]\n");
	assertEquals("Check ", "No: Suggestion=Isosceles1, Wrong Even/Odd", c.evaluateGuess("Rectangle,Large,Yes,1989,1989,3351"));
	}
	@Test
	public void test_threewise108() {
	System.out.println("======================== Test Case threewise108 ========================\n");
	System.out.println("Input: [Square,Large,No,1221,1221,1221,1221]\n");
	System.out.println("Expected Output: [Yes: ]\n");
	assertEquals("Check ", "Yes: ", c.evaluateGuess("Square,Large,No,1221,1221,1221,1221"));
	}
	@Test
	public void test_threewise109() {
	System.out.println("======================== Test Case threewise109 ========================\n");
	System.out.println("Input: [Circle,Large,Yes,2476,2476]\n");
	System.out.println("Expected Output: [Yes: ]\n");
	assertEquals("Check ", "Yes: ", c.evaluateGuess("Circle,Large,Yes,2476,2476"));
	}
	@Test
	public void test_threewise110() {
	System.out.println("======================== Test Case threewise110 ========================\n");
	System.out.println("Input: [Equilateral,Large,Yes,7,22,47]\n");
	System.out.println("Expected Output: [No: Suggestion=Not A Triangle, Wrong Size]\n");
	assertEquals("Check ", "No: Suggestion=Not A Triangle, Wrong Size", c.evaluateGuess("Equilateral,Large,Yes,7,22,47"));
	}
	@Test
	public void test_threewise111() {
	System.out.println("======================== Test Case threewise111 ========================\n");
	System.out.println("Input: [Ellipse,Small,No,2957,2957]\n");
	System.out.println("Expected Output: [No: Suggestion=Circle, Wrong Size]\n");
	assertEquals("Check ", "No: Suggestion=Circle, Wrong Size", c.evaluateGuess("Ellipse,Small,No,2957,2957"));
	}
	@Test
	public void test_threewise112() {
	System.out.println("======================== Test Case threewise112 ========================\n");
	System.out.println("Input: [Square,Large,Yes,235,3970,235,3970]\n");
	System.out.println("Expected Output: [No: Suggestion=Rectangle]\n");
	assertEquals("Check ", "No: Suggestion=Rectangle", c.evaluateGuess("Square,Large,Yes,235,3970,235,3970"));
	}
	@Test
	public void test_threewise113() {
	System.out.println("======================== Test Case threewise113 ========================\n");
	System.out.println("Input: [Line,Small,Yes,2197,659,2235]\n");
	System.out.println("Expected Output: [Bad guess limit Exceeded]\n");
	assertEquals("Check ", "Bad guess limit Exceeded", c.evaluateGuess("Line,Small,Yes,2197,659,2235"));
	}
	@Test
	public void test_threewise114() {
	System.out.println("======================== Test Case threewise114 ========================\n");
	System.out.println("Input: [Scalene,Small,Yes,165,1127,4029,2071]\n");
	System.out.println("Expected Output: [Bad guess limit Exceeded]\n");
	assertEquals("Check ", "Bad guess limit Exceeded", c.evaluateGuess("Scalene,Small,Yes,165,1127,4029,2071"));
	}
	@Test
	public void test_threewise115() {
	System.out.println("======================== Test Case threewise115 ========================\n");
	System.out.println("Input: [Rectangle,Small,No,1929,3765,445]\n");
	System.out.println("Expected Output: [No: Suggestion=Not A Triangle, Wrong Size]\n");
	assertEquals("Check ", "No: Suggestion=Not A Triangle, Wrong Size", c.evaluateGuess("Rectangle,Small,No,1929,3765,445"));
	}
	@Test
	public void test_threewise116() {
	System.out.println("======================== Test Case threewise116 ========================\n");
	System.out.println("Input: [Equilateral,Small,Yes,113,643,643]\n");
	System.out.println("Expected Output: [Bad guess limit Exceeded]\n");
	assertEquals("Check ", "Bad guess limit Exceeded", c.evaluateGuess("Equilateral,Small,Yes,113,643,643"));
	}
	@Test
	public void test_threewise117() {
	System.out.println("======================== Test Case threewise117 ========================\n");
	System.out.println("Input: [Ellipse,Small,Yes,1749,2925,1633]\n");
	System.out.println("Expected Output: [Bad guess limit Exceeded]\n");
	assertEquals("Check ", "Bad guess limit Exceeded", c.evaluateGuess("Ellipse,Small,Yes,1749,2925,1633"));
	}
	@Test
	public void test_threewise118() {
	System.out.println("======================== Test Case threewise118 ========================\n");
	System.out.println("Input: [Line,Large,Yes,515,491,515]\n");
	System.out.println("Expected Output: [No: Suggestion=Isosceles3, Wrong Even/Odd]\n");
	assertEquals("Check ", "No: Suggestion=Isosceles3, Wrong Even/Odd", c.evaluateGuess("Line,Large,Yes,515,491,515"));
	}
	@Test
	public void test_threewise119() {
	System.out.println("======================== Test Case threewise119 ========================\n");
	System.out.println("Input: [Rectangle,Large,No,1809]\n");
	System.out.println("Expected Output: [No: Suggestion=Line]\n");
	assertEquals("Check ", "No: Suggestion=Line", c.evaluateGuess("Rectangle,Large,No,1809"));
	}
	@Test
	public void test_threewise120() {
	System.out.println("======================== Test Case threewise120 ========================\n");
	System.out.println("Input: [Circle,Large,Yes,526,697,1349,2079]\n");
	System.out.println("Expected Output: [No: Suggestion=Not A Rectangle]\n");
	assertEquals("Check ", "No: Suggestion=Not A Rectangle", c.evaluateGuess("Circle,Large,Yes,526,697,1349,2079"));
	}
	@Test
	public void test_threewise121() {
	System.out.println("======================== Test Case threewise121 ========================\n");
	System.out.println("Input: [Scalene,Large,Yes,7,31,19]\n");
	System.out.println("Expected Output: [Bad guess limit Exceeded]\n");
	assertEquals("Check ", "Bad guess limit Exceeded", c.evaluateGuess("Scalene,Large,Yes,7,31,19"));
	}
	@Test
	public void test_threewise122() {
	System.out.println("======================== Test Case threewise122 ========================\n");
	System.out.println("Input: [Line,Large,Yes,1346,1609,3675]\n");
	System.out.println("Expected Output: [No: Suggestion=Not A Triangle]\n");
	assertEquals("Check ", "No: Suggestion=Not A Triangle", c.evaluateGuess("Line,Large,Yes,1346,1609,3675"));
	}
	@Test
	public void test_threewise123() {
	System.out.println("======================== Test Case threewise123 ========================\n");
	System.out.println("Input: [Rectangle,Large,Yes,4089,3237,3237]\n");
	System.out.println("Expected Output: [No: Suggestion=Isosceles2, Wrong Even/Odd]\n");
	assertEquals("Check ", "No: Suggestion=Isosceles2, Wrong Even/Odd", c.evaluateGuess("Rectangle,Large,Yes,4089,3237,3237"));
	}
	@Test
	public void test_threewise124() {
	System.out.println("======================== Test Case threewise124 ========================\n");
	System.out.println("Input: [Line,Large,Yes,2936,2936,3812]\n");
	System.out.println("Expected Output: [No: Suggestion=Isosceles1]\n");
	assertEquals("Check ", "No: Suggestion=Isosceles1", c.evaluateGuess("Line,Large,Yes,2936,2936,3812"));
	}
	@Test
	public void test_threewise125() {
	System.out.println("======================== Test Case threewise125 ========================\n");
	System.out.println("Input: [Ellipse,Small,Yes,4015]\n");
	System.out.println("Expected Output: [Bad guess limit Exceeded]\n");
	assertEquals("Check ", "Bad guess limit Exceeded", c.evaluateGuess("Ellipse,Small,Yes,4015"));
	}
	@Test
	public void test_threewise126() {
	System.out.println("======================== Test Case threewise126 ========================\n");
	System.out.println("Input: [Circle,Large,No,928,928,928]\n");
	System.out.println("Expected Output: [No: Suggestion=Equilateral, Wrong Even/Odd]\n");
	assertEquals("Check ", "No: Suggestion=Equilateral, Wrong Even/Odd", c.evaluateGuess("Circle,Large,No,928,928,928"));
	}
	@Test
	public void test_threewise127() {
	System.out.println("======================== Test Case threewise127 ========================\n");
	System.out.println("Input: [Rectangle,Large,No,0,0]\n");
	System.out.println("Expected Output: [Bad guess limit Exceeded]\n");
	assertEquals("Check ", "Bad guess limit Exceeded", c.evaluateGuess("Rectangle,Large,No,0,0"));
	}
	@Test
	public void test_threewise128() {
	System.out.println("======================== Test Case threewise128 ========================\n");
	System.out.println("Input: [Square,Large,No,9,6]\n");
	System.out.println("Expected Output: [Bad guess limit Exceeded]\n");
	assertEquals("Check ", "Bad guess limit Exceeded", c.evaluateGuess("Square,Large,No,9,6"));
	}
	@Test
	public void test_threewise129() {
	System.out.println("======================== Test Case threewise129 ========================\n");
	System.out.println("Input: [Circle,Small,No,31,11,7]\n");
	System.out.println("Expected Output: [No: Suggestion=Not A Triangle]\n");
	assertEquals("Check ", "No: Suggestion=Not A Triangle", c.evaluateGuess("Circle,Small,No,31,11,7"));
	}
	@Test
	public void test_threewise130() {
	System.out.println("======================== Test Case threewise130 ========================\n");
	System.out.println("Input: [Isosceles,Small,No,11,8,24]\n");
	System.out.println("Expected Output: [No: Suggestion=Not A Triangle, Wrong Even/Odd]\n");
	assertEquals("Check ", "No: Suggestion=Not A Triangle, Wrong Even/Odd", c.evaluateGuess("Isosceles,Small,No,11,8,24"));
	}
	@Test
	public void test_threewise131() {
	System.out.println("======================== Test Case threewise131 ========================\n");
	System.out.println("Input: [Isosceles,Large,Yes,133,2991,2337]\n");
	System.out.println("Expected Output: [No: Suggestion=Not A Triangle, Wrong Even/Odd]\n");
	assertEquals("Check ", "No: Suggestion=Not A Triangle, Wrong Even/Odd", c.evaluateGuess("Isosceles,Large,Yes,133,2991,2337"));
	}
	@Test
	public void test_threewise132() {
	System.out.println("======================== Test Case threewise132 ========================\n");
	System.out.println("Input: [Circle,Large,Yes,19,25,19,25]\n");
	System.out.println("Expected Output: [Bad guess limit Exceeded]\n");
	assertEquals("Check ", "Bad guess limit Exceeded", c.evaluateGuess("Circle,Large,Yes,19,25,19,25"));
	}
	@Test
	public void test_threewise133() {
	System.out.println("======================== Test Case threewise133 ========================\n");
	System.out.println("Input: [Square,Small,Yes,2842,1655,2842]\n");
	System.out.println("Expected Output: [No: Suggestion=Isosceles3, Wrong Size]\n");
	assertEquals("Check ", "No: Suggestion=Isosceles3, Wrong Size", c.evaluateGuess("Square,Small,Yes,2842,1655,2842"));
	}
	@Test
	public void test_threewise134() {
	System.out.println("======================== Test Case threewise134 ========================\n");
	System.out.println("Input: [Rectangle,Small,No,14,16,16]\n");
	System.out.println("Expected Output: [No: Suggestion=Isosceles2, Wrong Even/Odd]\n");
	assertEquals("Check ", "No: Suggestion=Isosceles2, Wrong Even/Odd", c.evaluateGuess("Rectangle,Small,No,14,16,16"));
	}
	@Test
	public void test_threewise135() {
	System.out.println("======================== Test Case threewise135 ========================\n");
	System.out.println("Input: [Equilateral,Large,No,1417,1479,1417]\n");
	System.out.println("Expected Output: [No: Suggestion=Isosceles3]\n");
	assertEquals("Check ", "No: Suggestion=Isosceles3", c.evaluateGuess("Equilateral,Large,No,1417,1479,1417"));
	}
	@Test
	public void test_threewise136() {
	System.out.println("======================== Test Case threewise136 ========================\n");
	System.out.println("Input: [Equilateral,Small,Yes,2,2,2]\n");
	System.out.println("Expected Output: [Yes: ]\n");
	assertEquals("Check ", "Yes: ", c.evaluateGuess("Equilateral,Small,Yes,2,2,2"));
	}
	@Test
	public void test_threewise137() {
	System.out.println("======================== Test Case threewise137 ========================\n");
	System.out.println("Input: [Scalene,Small,No,51,3912,3133]\n");
	System.out.println("Expected Output: [Bad guess limit Exceeded]\n");
	assertEquals("Check ", "Bad guess limit Exceeded", c.evaluateGuess("Scalene,Small,No,51,3912,3133"));
	}
	@Test
	public void test_threewise138() {
	System.out.println("======================== Test Case threewise138 ========================\n");
	System.out.println("Input: [Ellipse,Small,No,3,10,10]\n");
	System.out.println("Expected Output: [No: Suggestion=Isosceles2, Wrong Even/Odd]\n");
	assertEquals("Check ", "No: Suggestion=Isosceles2, Wrong Even/Odd", c.evaluateGuess("Ellipse,Small,No,3,10,10"));
	}
	@Test
	public void test_threewise139() {
	System.out.println("======================== Test Case threewise139 ========================\n");
	System.out.println("Input: [Scalene,Small,No,2831,2831,2831,2831]\n");
	System.out.println("Expected Output: [No: Suggestion=Square, Wrong Size]\n");
	assertEquals("Check ", "No: Suggestion=Square, Wrong Size", c.evaluateGuess("Scalene,Small,No,2831,2831,2831,2831"));
	}
	@Test
	public void test_threewise140() {
	System.out.println("======================== Test Case threewise140 ========================\n");
	System.out.println("Input: [Scalene,Small,Yes,11,11]\n");
	System.out.println("Expected Output: [No: Suggestion=Circle, Wrong Even/Odd]\n");
	assertEquals("Check ", "No: Suggestion=Circle, Wrong Even/Odd", c.evaluateGuess("Scalene,Small,Yes,11,11"));
	}
	@Test
	public void test_threewise141() {
	System.out.println("======================== Test Case threewise141 ========================\n");
	System.out.println("Input: [Scalene,Small,No,6,14,17]\n");
	System.out.println("Expected Output: [No: Wrong Even/Odd]\n");
	assertEquals("Check ", "No: Wrong Even/Odd", c.evaluateGuess("Scalene,Small,No,6,14,17"));
	}
	@Test
	public void test_threewise142() {
	System.out.println("======================== Test Case threewise142 ========================\n");
	System.out.println("Input: [Square,Small,Yes,3673,1399,1049]\n");
	System.out.println("Expected Output: [Bad guess limit Exceeded]\n");
	assertEquals("Check ", "Bad guess limit Exceeded", c.evaluateGuess("Square,Small,Yes,3673,1399,1049"));
	}
	@Test
	public void test_threewise143() {
	System.out.println("======================== Test Case threewise143 ========================\n");
	System.out.println("Input: [Line,Small,Yes,8,8,8,8]\n");
	System.out.println("Expected Output: [No: Suggestion=Square]\n");
	assertEquals("Check ", "No: Suggestion=Square", c.evaluateGuess("Line,Small,Yes,8,8,8,8"));
	}
	@Test
	public void test_threewise144() {
	System.out.println("======================== Test Case threewise144 ========================\n");
	System.out.println("Input: [Scalene,Small,No,41,41,15]\n");
	System.out.println("Expected Output: [No: Suggestion=Isosceles1]\n");
	assertEquals("Check ", "No: Suggestion=Isosceles1", c.evaluateGuess("Scalene,Small,No,41,41,15"));
	}
	@Test
	public void test_threewise145() {
	System.out.println("======================== Test Case threewise145 ========================\n");
	System.out.println("Input: [Isosceles,Small,Yes,1,1,1]\n");
	System.out.println("Expected Output: [No: Suggestion=Equilateral, Wrong Even/Odd]\n");
	assertEquals("Check ", "No: Suggestion=Equilateral, Wrong Even/Odd", c.evaluateGuess("Isosceles,Small,Yes,1,1,1"));
	}
	@Test
	public void test_threewise146() {
	System.out.println("======================== Test Case threewise146 ========================\n");
	System.out.println("Input: [Equilateral,Small,No,367,2423,367,2423]\n");
	System.out.println("Expected Output: [No: Suggestion=Rectangle, Wrong Size]\n");
	assertEquals("Check ", "No: Suggestion=Rectangle, Wrong Size", c.evaluateGuess("Equilateral,Small,No,367,2423,367,2423"));
	}
	@Test
	public void test_threewise147() {
	System.out.println("======================== Test Case threewise147 ========================\n");
	System.out.println("Input: [Ellipse,Small,Yes,532,532,532,532]\n");
	System.out.println("Expected Output: [No: Suggestion=Square, Wrong Size]\n");
	assertEquals("Check ", "No: Suggestion=Square, Wrong Size", c.evaluateGuess("Ellipse,Small,Yes,532,532,532,532"));
	}
	@Test
	public void test_threewise148() {
	System.out.println("======================== Test Case threewise148 ========================\n");
	System.out.println("Input: [Scalene,Small,Yes,1225]\n");
	System.out.println("Expected Output: [Bad guess limit Exceeded]\n");
	assertEquals("Check ", "Bad guess limit Exceeded", c.evaluateGuess("Scalene,Small,Yes,1225"));
	}
	@Test
	public void test_threewise149() {
	System.out.println("======================== Test Case threewise149 ========================\n");
	System.out.println("Input: [Isosceles,Large,No,3,11,5,5]\n");
	System.out.println("Expected Output: [No: Suggestion=Not A Rectangle, Wrong Size]\n");
	assertEquals("Check ", "No: Suggestion=Not A Rectangle, Wrong Size", c.evaluateGuess("Isosceles,Large,No,3,11,5,5"));
	}
	@Test
	public void test_threewise150() {
	System.out.println("======================== Test Case threewise150 ========================\n");
	System.out.println("Input: [Scalene,Small,No,6,6]\n");
	System.out.println("Expected Output: [No: Suggestion=Ellipse, Wrong Even/Odd]\n");
	assertEquals("Check ", "No: Suggestion=Ellipse, Wrong Even/Odd", c.evaluateGuess("Scalene,Small,No,6,6"));
	}
	@Test
	public void test_threewise151() {
	System.out.println("======================== Test Case threewise151 ========================\n");
	System.out.println("Input: [Isosceles,Large,No,23,27,19]\n");
	System.out.println("Expected Output: [No: Suggestion=Scalene, Wrong Size]\n");
	assertEquals("Check ", "No: Suggestion=Scalene, Wrong Size", c.evaluateGuess("Isosceles,Large,No,23,27,19"));
	}
	@Test
	public void test_threewise152() {
	System.out.println("======================== Test Case threewise152 ========================\n");
	System.out.println("Input: [Equilateral,Small,No,7,1,5]\n");
	System.out.println("Expected Output: [No: Suggestion=Not A Triangle]\n");
	assertEquals("Check ", "No: Suggestion=Not A Triangle", c.evaluateGuess("Equilateral,Small,No,7,1,5"));
	}
	@Test
	public void test_threewise153() {
	System.out.println("======================== Test Case threewise153 ========================\n");
	System.out.println("Input: [Equilateral,Small,No,1941,727,3005]\n");
	System.out.println("Expected Output: [No: Suggestion=Not A Triangle, Wrong Size]\n");
	assertEquals("Check ", "No: Suggestion=Not A Triangle, Wrong Size", c.evaluateGuess("Equilateral,Small,No,1941,727,3005"));
	}
	@Test
	public void test_threewise154() {
	System.out.println("======================== Test Case threewise154 ========================\n");
	System.out.println("Input: [Rectangle,Small,No,33,33,32]\n");
	System.out.println("Expected Output: [No: Suggestion=Isosceles1, Wrong Even/Odd]\n");
	assertEquals("Check ", "No: Suggestion=Isosceles1, Wrong Even/Odd", c.evaluateGuess("Rectangle,Small,No,33,33,32"));
	}
	@Test
	public void test_threewise155() {
	System.out.println("======================== Test Case threewise155 ========================\n");
	System.out.println("Input: [Ellipse,Large,Yes,10,10]\n");
	System.out.println("Expected Output: [No: Suggestion=Circle, Wrong Size]\n");
	assertEquals("Check ", "No: Suggestion=Circle, Wrong Size", c.evaluateGuess("Ellipse,Large,Yes,10,10"));
	}
	@Test
	public void test_threewise156() {
	System.out.println("======================== Test Case threewise156 ========================\n");
	System.out.println("Input: [Square,Small,No,5,9,5,9]\n");
	System.out.println("Expected Output: [No: Suggestion=Rectangle]\n");
	assertEquals("Check ", "No: Suggestion=Rectangle", c.evaluateGuess("Square,Small,No,5,9,5,9"));
	}
	@Test
	public void test_threewise157() {
	System.out.println("======================== Test Case threewise157 ========================\n");
	System.out.println("Input: [Equilateral,Small,Yes,1013,4083,2920]\n");
	System.out.println("Expected Output: [No: Suggestion=Not A Triangle, Wrong Size]\n");
	assertEquals("Check ", "No: Suggestion=Not A Triangle, Wrong Size", c.evaluateGuess("Equilateral,Small,Yes,1013,4083,2920"));
	}
	@Test
	public void test_threewise158() {
	System.out.println("======================== Test Case threewise158 ========================\n");
	System.out.println("Input: [Line,Large,Yes,4,16]\n");
	System.out.println("Expected Output: [No: Suggestion=Ellipse, Wrong Size]\n");
	assertEquals("Check ", "No: Suggestion=Ellipse, Wrong Size", c.evaluateGuess("Line,Large,Yes,4,16"));
	}
	@Test
	public void test_threewise159() {
	System.out.println("======================== Test Case threewise159 ========================\n");
	System.out.println("Input: [Circle,Small,Yes,27,27,27]\n");
	System.out.println("Expected Output: [No: Suggestion=Equilateral, Wrong Even/Odd]\n");
	assertEquals("Check ", "No: Suggestion=Equilateral, Wrong Even/Odd", c.evaluateGuess("Circle,Small,Yes,27,27,27"));
	}
	@Test
	public void test_threewise160() {
	System.out.println("======================== Test Case threewise160 ========================\n");
	System.out.println("Input: [Line,Large,No,11,40,47]\n");
	System.out.println("Expected Output: [Bad guess limit Exceeded]\n");
	assertEquals("Check ", "Bad guess limit Exceeded", c.evaluateGuess("Line,Large,No,11,40,47"));
	}
	@Test
	public void test_threewise161() {
	System.out.println("======================== Test Case threewise161 ========================\n");
	System.out.println("Input: [Ellipse,Large,Yes,19,19,33]\n");
	System.out.println("Expected Output: [Bad guess limit Exceeded]\n");
	assertEquals("Check ", "Bad guess limit Exceeded", c.evaluateGuess("Ellipse,Large,Yes,19,19,33"));
	}
	@Test
	public void test_threewise162() {
	System.out.println("======================== Test Case threewise162 ========================\n");
	System.out.println("Input: [Circle,Small,No,33,25,33]\n");
	System.out.println("Expected Output: [No: Suggestion=Isosceles3]\n");
	assertEquals("Check ", "No: Suggestion=Isosceles3", c.evaluateGuess("Circle,Small,No,33,25,33"));
	}
	@Test
	public void test_threewise163() {
	System.out.println("======================== Test Case threewise163 ========================\n");
	System.out.println("Input: [Ellipse,Small,Yes,18,27,27,7]\n");
	System.out.println("Expected Output: [No: Suggestion=Not A Rectangle]\n");
	assertEquals("Check ", "No: Suggestion=Not A Rectangle", c.evaluateGuess("Ellipse,Small,Yes,18,27,27,7"));
	}
	@Test
	public void test_threewise164() {
	System.out.println("======================== Test Case threewise164 ========================\n");
	System.out.println("Input: [Isosceles,Large,No,3459,1945,911]\n");
	System.out.println("Expected Output: [No: Suggestion=Not A Triangle]\n");
	assertEquals("Check ", "No: Suggestion=Not A Triangle", c.evaluateGuess("Isosceles,Large,No,3459,1945,911"));
	}
	@Test
	public void test_threewise165() {
	System.out.println("======================== Test Case threewise165 ========================\n");
	System.out.println("Input: [Circle,Large,No,9,7,17]\n");
	System.out.println("Expected Output: [No: Suggestion=Not A Triangle, Wrong Size]\n");
	assertEquals("Check ", "No: Suggestion=Not A Triangle, Wrong Size", c.evaluateGuess("Circle,Large,No,9,7,17"));
	}
	@Test
	public void test_threewise166() {
	System.out.println("======================== Test Case threewise166 ========================\n");
	System.out.println("Input: [Circle,Large,No,37,258,258]\n");
	System.out.println("Expected Output: [No: Suggestion=Isosceles2, Wrong Even/Odd]\n");
	assertEquals("Check ", "No: Suggestion=Isosceles2, Wrong Even/Odd", c.evaluateGuess("Circle,Large,No,37,258,258"));
	}
	@Test
	public void test_threewise167() {
	System.out.println("======================== Test Case threewise167 ========================\n");
	System.out.println("Input: [Isosceles,Large,No,37]\n");
	System.out.println("Expected Output: [No: Suggestion=Line, Wrong Size]\n");
	assertEquals("Check ", "No: Suggestion=Line, Wrong Size", c.evaluateGuess("Isosceles,Large,No,37"));
	}
	@Test
	public void test_threewise168() {
	System.out.println("======================== Test Case threewise168 ========================\n");
	System.out.println("Input: [Square,Small,Yes,24,24,24,24]\n");
	System.out.println("Expected Output: [Yes: ]\n");
	assertEquals("Check ", "Yes: ", c.evaluateGuess("Square,Small,Yes,24,24,24,24"));
	}
	@Test
	public void test_threewise169() {
	System.out.println("======================== Test Case threewise169 ========================\n");
	System.out.println("Input: [Rectangle,Large,Yes,1681,1681]\n");
	System.out.println("Expected Output: [No: Suggestion=Circle, Wrong Even/Odd]\n");
	assertEquals("Check ", "No: Suggestion=Circle, Wrong Even/Odd", c.evaluateGuess("Rectangle,Large,Yes,1681,1681"));
	}
	@Test
	public void test_threewise170() {
	System.out.println("======================== Test Case threewise170 ========================\n");
	System.out.println("Input: [Square,Large,Yes,207,3607,3057]\n");
	System.out.println("Expected Output: [No: Suggestion=Not A Triangle, Wrong Even/Odd]\n");
	assertEquals("Check ", "No: Suggestion=Not A Triangle, Wrong Even/Odd", c.evaluateGuess("Square,Large,Yes,207,3607,3057"));
	}
	@Test
	public void test_threewise171() {
	System.out.println("======================== Test Case threewise171 ========================\n");
	System.out.println("Input: [Isosceles,Large,Yes,21,30,30]\n");
	System.out.println("Expected Output: [No: Suggestion=Isosceles2, Wrong Size]\n");
	assertEquals("Check ", "No: Suggestion=Isosceles2, Wrong Size", c.evaluateGuess("Isosceles,Large,Yes,21,30,30"));
	}
	@Test
	public void test_threewise172() {
	System.out.println("======================== Test Case threewise172 ========================\n");
	System.out.println("Input: [Rectangle,Small,No,10,15,10]\n");
	System.out.println("Expected Output: [No: Suggestion=Isosceles3, Wrong Even/Odd]\n");
	assertEquals("Check ", "No: Suggestion=Isosceles3, Wrong Even/Odd", c.evaluateGuess("Rectangle,Small,No,10,15,10"));
	}
	@Test
	public void test_threewise173() {
	System.out.println("======================== Test Case threewise173 ========================\n");
	System.out.println("Input: [Equilateral,Large,Yes,9,9]\n");
	System.out.println("Expected Output: [Bad guess limit Exceeded]\n");
	assertEquals("Check ", "Bad guess limit Exceeded", c.evaluateGuess("Equilateral,Large,Yes,9,9"));
	}
	@Test
	public void test_threewise174() {
	System.out.println("======================== Test Case threewise174 ========================\n");
	System.out.println("Input: [Line,Small,Yes,3,1,3,1]\n");
	System.out.println("Expected Output: [No: Suggestion=Rectangle, Wrong Even/Odd]\n");
	assertEquals("Check ", "No: Suggestion=Rectangle, Wrong Even/Odd", c.evaluateGuess("Line,Small,Yes,3,1,3,1"));
	}
	@Test
	public void test_threewise175() {
	System.out.println("======================== Test Case threewise175 ========================\n");
	System.out.println("Input: [Square,Large,Yes,7,5,5]\n");
	System.out.println("Expected Output: [Bad guess limit Exceeded]\n");
	assertEquals("Check ", "Bad guess limit Exceeded", c.evaluateGuess("Square,Large,Yes,7,5,5"));
	}
	@Test
	public void test_threewise176() {
	System.out.println("======================== Test Case threewise176 ========================\n");
	System.out.println("Input: [Rectangle,Large,Yes,23,8,27,8]\n");
	System.out.println("Expected Output: [No: Suggestion=Not A Rectangle, Wrong Size]\n");
	assertEquals("Check ", "No: Suggestion=Not A Rectangle, Wrong Size", c.evaluateGuess("Rectangle,Large,Yes,23,8,27,8"));
	}
	@Test
	public void test_threewise177() {
	System.out.println("======================== Test Case threewise177 ========================\n");
	System.out.println("Input: [Scalene,Large,Yes,42,1,16]\n");
	System.out.println("Expected Output: [No: Suggestion=Not A Triangle, Wrong Size]\n");
	assertEquals("Check ", "No: Suggestion=Not A Triangle, Wrong Size", c.evaluateGuess("Scalene,Large,Yes,42,1,16"));
	}
	@Test
	public void test_threewise178() {
	System.out.println("======================== Test Case threewise178 ========================\n");
	System.out.println("Input: [Ellipse,Large,Yes,13,9,13]\n");
	System.out.println("Expected Output: [Bad guess limit Exceeded]\n");
	assertEquals("Check ", "Bad guess limit Exceeded", c.evaluateGuess("Ellipse,Large,Yes,13,9,13"));
	}
	@Test
	public void test_threewise179() {
	System.out.println("======================== Test Case threewise179 ========================\n");
	System.out.println("Input: [Line,Small,No,34,5,4]\n");
	System.out.println("Expected Output: [No: Suggestion=Not A Triangle, Wrong Even/Odd]\n");
	assertEquals("Check ", "No: Suggestion=Not A Triangle, Wrong Even/Odd", c.evaluateGuess("Line,Small,No,34,5,4"));
	}
	@Test
	public void test_threewise180() {
	System.out.println("======================== Test Case threewise180 ========================\n");
	System.out.println("Input: [Equilateral,Small,No,23,21,3]\n");
	System.out.println("Expected Output: [No: Suggestion=Scalene]\n");
	assertEquals("Check ", "No: Suggestion=Scalene", c.evaluateGuess("Equilateral,Small,No,23,21,3"));
	}
	@Test
	public void test_threewise181() {
	System.out.println("======================== Test Case threewise181 ========================\n");
	System.out.println("Input: [Equilateral,Large,Yes,2621,2621]\n");
	System.out.println("Expected Output: [No: Suggestion=Circle, Wrong Even/Odd]\n");
	assertEquals("Check ", "No: Suggestion=Circle, Wrong Even/Odd", c.evaluateGuess("Equilateral,Large,Yes,2621,2621"));
	}
	@Test
	public void test_threewise182() {
	System.out.println("======================== Test Case threewise182 ========================\n");
	System.out.println("Input: [Circle,Large,Yes,28]\n");
	System.out.println("Expected Output: [No: Suggestion=Line, Wrong Size]\n");
	assertEquals("Check ", "No: Suggestion=Line, Wrong Size", c.evaluateGuess("Circle,Large,Yes,28"));
	}
	@Test
	public void test_threewise183() {
	System.out.println("======================== Test Case threewise183 ========================\n");
	System.out.println("Input: [Square,Small,No,2701,993,4009]\n");
	System.out.println("Expected Output: [No: Suggestion=Not A Triangle, Wrong Size]\n");
	assertEquals("Check ", "No: Suggestion=Not A Triangle, Wrong Size", c.evaluateGuess("Square,Small,No,2701,993,4009"));
	}
	@Test
	public void test_threewise184() {
	System.out.println("======================== Test Case threewise184 ========================\n");
	System.out.println("Input: [Ellipse,Small,No,939,939,939]\n");
	System.out.println("Expected Output: [No: Suggestion=Equilateral, Wrong Size]\n");
	assertEquals("Check ", "No: Suggestion=Equilateral, Wrong Size", c.evaluateGuess("Ellipse,Small,No,939,939,939"));
	}
	@Test
	public void test_threewise185() {
	System.out.println("======================== Test Case threewise185 ========================\n");
	System.out.println("Input: [Isosceles,Small,Yes,423,383,423]\n");
	System.out.println("Expected Output: [Bad guess limit Exceeded]\n");
	assertEquals("Check ", "Bad guess limit Exceeded", c.evaluateGuess("Isosceles,Small,Yes,423,383,423"));
	}
	@Test
	public void test_threewise186() {
	System.out.println("======================== Test Case threewise186 ========================\n");
	System.out.println("Input: [Square,Large,No,34,34,13]\n");
	System.out.println("Expected Output: [Bad guess limit Exceeded]\n");
	assertEquals("Check ", "Bad guess limit Exceeded", c.evaluateGuess("Square,Large,No,34,34,13"));
	}
	@Test
	public void test_threewise187() {
	System.out.println("======================== Test Case threewise187 ========================\n");
	System.out.println("Input: [Line,Small,Yes,75]\n");
	System.out.println("Expected Output: [No: Wrong Even/Odd]\n");
	assertEquals("Check ", "No: Wrong Even/Odd", c.evaluateGuess("Line,Small,Yes,75"));
	}
	@Test
	public void test_threewise188() {
	System.out.println("======================== Test Case threewise188 ========================\n");
	System.out.println("Input: [Rectangle,Small,Yes,8,32,8,32]\n");
	System.out.println("Expected Output: [Yes: ]\n");
	assertEquals("Check ", "Yes: ", c.evaluateGuess("Rectangle,Small,Yes,8,32,8,32"));
	}
	@Test
	public void test_threewise189() {
	System.out.println("======================== Test Case threewise189 ========================\n");
	System.out.println("Input: [Circle,Small,No,1047,3970,2836]\n");
	System.out.println("Expected Output: [Bad guess limit Exceeded]\n");
	assertEquals("Check ", "Bad guess limit Exceeded", c.evaluateGuess("Circle,Small,No,1047,3970,2836"));
	}
	@Test
	public void test_threewise190() {
	System.out.println("======================== Test Case threewise190 ========================\n");
	System.out.println("Input: [Ellipse,Large,Yes,4050,880,3079]\n");
	System.out.println("Expected Output: [No: Suggestion=Not A Triangle]\n");
	assertEquals("Check ", "No: Suggestion=Not A Triangle", c.evaluateGuess("Ellipse,Large,Yes,4050,880,3079"));
	}
	@Test
	public void test_threewise191() {
	System.out.println("======================== Test Case threewise191 ========================\n");
	System.out.println("Input: [Line,Small,No,2310,2310,2310]\n");
	System.out.println("Expected Output: [Bad guess limit Exceeded]\n");
	assertEquals("Check ", "Bad guess limit Exceeded", c.evaluateGuess("Line,Small,No,2310,2310,2310"));
	}
	@Test
	public void test_threewise192() {
	System.out.println("======================== Test Case threewise192 ========================\n");
	System.out.println("Input: [Circle,Large,No,1156,1156,1156,1156]\n");
	System.out.println("Expected Output: [No: Suggestion=Square, Wrong Even/Odd]\n");
	assertEquals("Check ", "No: Suggestion=Square, Wrong Even/Odd", c.evaluateGuess("Circle,Large,No,1156,1156,1156,1156"));
	}
	@Test
	public void test_threewise193() {
	System.out.println("======================== Test Case threewise193 ========================\n");
	System.out.println("Input: [Ellipse,Small,No,3493,2397]\n");
	System.out.println("Expected Output: [No: Wrong Size]\n");
	assertEquals("Check ", "No: Wrong Size", c.evaluateGuess("Ellipse,Small,No,3493,2397"));
	}
	@Test
	public void test_threewise194() {
	System.out.println("======================== Test Case threewise194 ========================\n");
	System.out.println("Input: [Square,Large,Yes,17,18,28]\n");
	System.out.println("Expected Output: [No: Suggestion=Scalene, Wrong Size]\n");
	assertEquals("Check ", "No: Suggestion=Scalene, Wrong Size", c.evaluateGuess("Square,Large,Yes,17,18,28"));
	}
	@Test
	public void test_threewise195() {
	System.out.println("======================== Test Case threewise195 ========================\n");
	System.out.println("Input: [Isosceles,Small,Yes,1330,15,1330,15]\n");
	System.out.println("Expected Output: [No: Suggestion=Rectangle, Wrong Size]\n");
	assertEquals("Check ", "No: Suggestion=Rectangle, Wrong Size", c.evaluateGuess("Isosceles,Small,Yes,1330,15,1330,15"));
	}
	@Test
	public void test_threewise196() {
	System.out.println("======================== Test Case threewise196 ========================\n");
	System.out.println("Input: [Isosceles,Small,Yes,12,12]\n");
	System.out.println("Expected Output: [No: Suggestion=Circle]\n");
	assertEquals("Check ", "No: Suggestion=Circle", c.evaluateGuess("Isosceles,Small,Yes,12,12"));
	}
	@Test
	public void test_threewise197() {
	System.out.println("======================== Test Case threewise197 ========================\n");
	System.out.println("Input: [Isosceles,Large,No,2128,2128,1081]\n");
	System.out.println("Expected Output: [No: Suggestion=Isosceles1, Wrong Even/Odd]\n");
	assertEquals("Check ", "No: Suggestion=Isosceles1, Wrong Even/Odd", c.evaluateGuess("Isosceles,Large,No,2128,2128,1081"));
	}
	@Test
	public void test_threewise198() {
	System.out.println("======================== Test Case threewise198 ========================\n");
	System.out.println("Input: [Line,Large,Yes,17,31,12,15]\n");
	System.out.println("Expected Output: [No: Suggestion=Not A Rectangle, Wrong Size]\n");
	assertEquals("Check ", "No: Suggestion=Not A Rectangle, Wrong Size", c.evaluateGuess("Line,Large,Yes,17,31,12,15"));
	}
	@Test
	public void test_threewise199() {
	System.out.println("======================== Test Case threewise199 ========================\n");
	System.out.println("Input: [Scalene,Small,Yes,5,3,9]\n");
	System.out.println("Expected Output: [No: Suggestion=Not A Triangle, Wrong Even/Odd]\n");
	assertEquals("Check ", "No: Suggestion=Not A Triangle, Wrong Even/Odd", c.evaluateGuess("Scalene,Small,Yes,5,3,9"));
	}
	@Test
	public void test_threewise200() {
	System.out.println("======================== Test Case threewise200 ========================\n");
	System.out.println("Input: [Equilateral,Large,No,1806]\n");
	System.out.println("Expected Output: [No: Suggestion=Line, Wrong Even/Odd]\n");
	assertEquals("Check ", "No: Suggestion=Line, Wrong Even/Odd", c.evaluateGuess("Equilateral,Large,No,1806"));
	}
	@Test
	public void test_threewise201() {
	System.out.println("======================== Test Case threewise201 ========================\n");
	System.out.println("Input: [Square,Small,No,2260,2260]\n");
	System.out.println("Expected Output: [Bad guess limit Exceeded]\n");
	assertEquals("Check ", "Bad guess limit Exceeded", c.evaluateGuess("Square,Small,No,2260,2260"));
	}
	@Test
	public void test_threewise202() {
	System.out.println("======================== Test Case threewise202 ========================\n");
	System.out.println("Input: [Isosceles,Large,Yes,801,801,801,801]\n");
	System.out.println("Expected Output: [No: Suggestion=Square, Wrong Even/Odd]\n");
	assertEquals("Check ", "No: Suggestion=Square, Wrong Even/Odd", c.evaluateGuess("Isosceles,Large,Yes,801,801,801,801"));
	}
	@Test
	public void test_threewise203() {
	System.out.println("======================== Test Case threewise203 ========================\n");
	System.out.println("Input: [Ellipse,Small,Yes,9,27,13]\n");
	System.out.println("Expected Output: [No: Suggestion=Not A Triangle, Wrong Even/Odd]\n");
	assertEquals("Check ", "No: Suggestion=Not A Triangle, Wrong Even/Odd", c.evaluateGuess("Ellipse,Small,Yes,9,27,13"));
	}
	@Test
	public void test_threewise204() {
	System.out.println("======================== Test Case threewise204 ========================\n");
	System.out.println("Input: [Circle,Small,Yes,3776,3660]\n");
	System.out.println("Expected Output: [No: Suggestion=Ellipse, Wrong Size]\n");
	assertEquals("Check ", "No: Suggestion=Ellipse, Wrong Size", c.evaluateGuess("Circle,Small,Yes,3776,3660"));
	}
	@Test
	public void test_threewise205() {
	System.out.println("======================== Test Case threewise205 ========================\n");
	System.out.println("Input: [Rectangle,Large,No,6,6,6]\n");
	System.out.println("Expected Output: [Bad guess limit Exceeded]\n");
	assertEquals("Check ", "Bad guess limit Exceeded", c.evaluateGuess("Rectangle,Large,No,6,6,6"));
	}
	@Test
	public void test_threewise206() {
	System.out.println("======================== Test Case threewise206 ========================\n");
	System.out.println("Input: [Rectangle,Small,Yes,2616,2008,315]\n");
	System.out.println("Expected Output: [No: Suggestion=Not A Triangle, Wrong Size]\n");
	assertEquals("Check ", "No: Suggestion=Not A Triangle, Wrong Size", c.evaluateGuess("Rectangle,Small,Yes,2616,2008,315"));
	}
	@Test
	public void test_threewise207() {
	System.out.println("======================== Test Case threewise207 ========================\n");
	System.out.println("Input: [Line,Small,Yes,1356,2888,2888]\n");
	System.out.println("Expected Output: [No: Suggestion=Isosceles2, Wrong Size]\n");
	assertEquals("Check ", "No: Suggestion=Isosceles2, Wrong Size", c.evaluateGuess("Line,Small,Yes,1356,2888,2888"));
	}
	@Test
	public void test_threewise208() {
	System.out.println("======================== Test Case threewise208 ========================\n");
	System.out.println("Input: [Circle,Small,Yes,2211,2211,393]\n");
	System.out.println("Expected Output: [Bad guess limit Exceeded]\n");
	assertEquals("Check ", "Bad guess limit Exceeded", c.evaluateGuess("Circle,Small,Yes,2211,2211,393"));
	}
	@Test
	public void test_threewise209() {
	System.out.println("======================== Test Case threewise209 ========================\n");
	System.out.println("Input: [Circle,Large,No,1982,110,2070]\n");
	System.out.println("Expected Output: [No: Suggestion=Scalene, Wrong Even/Odd]\n");
	assertEquals("Check ", "No: Suggestion=Scalene, Wrong Even/Odd", c.evaluateGuess("Circle,Large,No,1982,110,2070"));
	}
	@Test
	public void test_threewise210() {
	System.out.println("======================== Test Case threewise210 ========================\n");
	System.out.println("Input: [Equilateral,Small,No,2449,2163,3719,2367]\n");
	System.out.println("Expected Output: [No: Suggestion=Not A Rectangle, Wrong Size]\n");
	assertEquals("Check ", "No: Suggestion=Not A Rectangle, Wrong Size", c.evaluateGuess("Equilateral,Small,No,2449,2163,3719,2367"));
	}
	@Test
	public void test_threewise211() {
	System.out.println("======================== Test Case threewise211 ========================\n");
	System.out.println("Input: [Scalene,Large,Yes,3941,3941,3941]\n");
	System.out.println("Expected Output: [No: Suggestion=Equilateral, Wrong Even/Odd]\n");
	assertEquals("Check ", "No: Suggestion=Equilateral, Wrong Even/Odd", c.evaluateGuess("Scalene,Large,Yes,3941,3941,3941"));
	}
	@Test
	public void test_threewise212() {
	System.out.println("======================== Test Case threewise212 ========================\n");
	System.out.println("Input: [Rectangle,Small,Yes,27,3,57]\n");
	System.out.println("Expected Output: [No: Suggestion=Not A Triangle, Wrong Even/Odd]\n");
	assertEquals("Check ", "No: Suggestion=Not A Triangle, Wrong Even/Odd", c.evaluateGuess("Rectangle,Small,Yes,27,3,57"));
	}
	@Test
	public void test_threewise213() {
	System.out.println("======================== Test Case threewise213 ========================\n");
	System.out.println("Input: [Equilateral,Large,Yes,8,8,8,8]\n");
	System.out.println("Expected Output: [No: Suggestion=Square, Wrong Size]\n");
	assertEquals("Check ", "No: Suggestion=Square, Wrong Size", c.evaluateGuess("Equilateral,Large,Yes,8,8,8,8"));
	}
	@Test
	public void test_threewise214() {
	System.out.println("======================== Test Case threewise214 ========================\n");
	System.out.println("Input: [Scalene,Small,No,1588,2632,2632]\n");
	System.out.println("Expected Output: [Bad guess limit Exceeded]\n");
	assertEquals("Check ", "Bad guess limit Exceeded", c.evaluateGuess("Scalene,Small,No,1588,2632,2632"));
	}
	@Test
	public void test_threewise215() {
	System.out.println("======================== Test Case threewise215 ========================\n");
	System.out.println("Input: [Scalene,Large,No,1887,3406,1887]\n");
	System.out.println("Expected Output: [No: Suggestion=Isosceles3, Wrong Even/Odd]\n");
	assertEquals("Check ", "No: Suggestion=Isosceles3, Wrong Even/Odd", c.evaluateGuess("Scalene,Large,No,1887,3406,1887"));
	}
	@Test
	public void test_threewise216() {
	System.out.println("======================== Test Case threewise216 ========================\n");
	System.out.println("Input: [Ellipse,Large,No,901,2001,3272]\n");
	System.out.println("Expected Output: [No: Suggestion=Not A Triangle, Wrong Even/Odd]\n");
	assertEquals("Check ", "No: Suggestion=Not A Triangle, Wrong Even/Odd", c.evaluateGuess("Ellipse,Large,No,901,2001,3272"));
	}
	@Test
	public void test_threewise217() {
	System.out.println("======================== Test Case threewise217 ========================\n");
	System.out.println("Input: [Ellipse,Large,Yes,1745,3623,1745,3623]\n");
	System.out.println("Expected Output: [No: Suggestion=Rectangle, Wrong Even/Odd]\n");
	assertEquals("Check ", "No: Suggestion=Rectangle, Wrong Even/Odd", c.evaluateGuess("Ellipse,Large,Yes,1745,3623,1745,3623"));
	}
	@Test
	public void test_threewise218() {
	System.out.println("======================== Test Case threewise218 ========================\n");
	System.out.println("Input: [Line,Large,No,3,3]\n");
	System.out.println("Expected Output: [No: Suggestion=Circle, Wrong Size]\n");
	assertEquals("Check ", "No: Suggestion=Circle, Wrong Size", c.evaluateGuess("Line,Large,No,3,3"));
	}
	@Test
	public void test_threewise219() {
	System.out.println("======================== Test Case threewise219 ========================\n");
	System.out.println("Input: [Square,Small,No,1816]\n");
	System.out.println("Expected Output: [Bad guess limit Exceeded]\n");
	assertEquals("Check ", "Bad guess limit Exceeded", c.evaluateGuess("Square,Small,No,1816"));
	}
	@Test
	public void test_threewise220() {
	System.out.println("======================== Test Case threewise220 ========================\n");
	System.out.println("Input: [Equilateral,Small,No,9,9,8]\n");
	System.out.println("Expected Output: [No: Suggestion=Isosceles1, Wrong Even/Odd]\n");
	assertEquals("Check ", "No: Suggestion=Isosceles1, Wrong Even/Odd", c.evaluateGuess("Equilateral,Small,No,9,9,8"));
	}
	@Test
	public void test_threewise221() {
	System.out.println("======================== Test Case threewise221 ========================\n");
	System.out.println("Input: [Line,Large,No,13,32,18]\n");
	System.out.println("Expected Output: [Bad guess limit Exceeded]\n");
	assertEquals("Check ", "Bad guess limit Exceeded", c.evaluateGuess("Line,Large,No,13,32,18"));
	}
	@Test
	public void test_threewise222() {
	System.out.println("======================== Test Case threewise222 ========================\n");
	System.out.println("Input: [Isosceles,Large,No,6,2]\n");
	System.out.println("Expected Output: [Bad guess limit Exceeded]\n");
	assertEquals("Check ", "Bad guess limit Exceeded", c.evaluateGuess("Isosceles,Large,No,6,2"));
	}
	@Test
	public void test_threewise223() {
	System.out.println("======================== Test Case threewise223 ========================\n");
	System.out.println("Input: [Rectangle,Large,Yes,747,1805,1704]\n");
	System.out.println("Expected Output: [No: Suggestion=Scalene]\n");
	assertEquals("Check ", "No: Suggestion=Scalene", c.evaluateGuess("Rectangle,Large,Yes,747,1805,1704"));
	}
	@Test
	public void test_threewise224() {
	System.out.println("======================== Test Case threewise224 ========================\n");
	System.out.println("Input: [Square,Small,Yes,769,2535,2713,1957]\n");
	System.out.println("Expected Output: [Bad guess limit Exceeded]\n");
	assertEquals("Check ", "Bad guess limit Exceeded", c.evaluateGuess("Square,Small,Yes,769,2535,2713,1957"));
	}
	@Test
	public void test_threewise225() {
	System.out.println("======================== Test Case threewise225 ========================\n");
	System.out.println("Input: [Isosceles,Large,No,6,11,6,11]\n");
	System.out.println("Expected Output: [Bad guess limit Exceeded]\n");
	assertEquals("Check ", "Bad guess limit Exceeded", c.evaluateGuess("Isosceles,Large,No,6,11,6,11"));
	}
	@Test
	public void test_threewise226() {
	System.out.println("======================== Test Case threewise226 ========================\n");
	System.out.println("Input: [Scalene,Large,No,22,22,22,22]\n");
	System.out.println("Expected Output: [Bad guess limit Exceeded]\n");
	assertEquals("Check ", "Bad guess limit Exceeded", c.evaluateGuess("Scalene,Large,No,22,22,22,22"));
	}
	@Test
	public void test_threewise227() {
	System.out.println("======================== Test Case threewise227 ========================\n");
	System.out.println("Input: [Circle,Small,No,13,37,23]\n");
	System.out.println("Expected Output: [No: Suggestion=Not A Triangle]\n");
	assertEquals("Check ", "No: Suggestion=Not A Triangle", c.evaluateGuess("Circle,Small,No,13,37,23"));
	}
	@Test
	public void test_threewise228() {
	System.out.println("======================== Test Case threewise228 ========================\n");
	System.out.println("Input: [Circle,Small,Yes,11,13,13]\n");
	System.out.println("Expected Output: [No: Suggestion=Isosceles2, Wrong Even/Odd]\n");
	assertEquals("Check ", "No: Suggestion=Isosceles2, Wrong Even/Odd", c.evaluateGuess("Circle,Small,Yes,11,13,13"));
	}
	@Test
	public void test_threewise229() {
	System.out.println("======================== Test Case threewise229 ========================\n");
	System.out.println("Input: [Scalene,Small,Yes,12,35,12,35]\n");
	System.out.println("Expected Output: [No: Suggestion=Rectangle]\n");
	assertEquals("Check ", "No: Suggestion=Rectangle", c.evaluateGuess("Scalene,Small,Yes,12,35,12,35"));
	}
	@Test
	public void test_threewise230() {
	System.out.println("======================== Test Case threewise230 ========================\n");
	System.out.println("Input: [Rectangle,Large,No,3382,1486]\n");
	System.out.println("Expected Output: [No: Suggestion=Ellipse, Wrong Even/Odd]\n");
	assertEquals("Check ", "No: Suggestion=Ellipse, Wrong Even/Odd", c.evaluateGuess("Rectangle,Large,No,3382,1486"));
	}
	@Test
	public void test_threewise231() {
	System.out.println("======================== Test Case threewise231 ========================\n");
	System.out.println("Input: [Equilateral,Large,No,34,18,34]\n");
	System.out.println("Expected Output: [Bad guess limit Exceeded]\n");
	assertEquals("Check ", "Bad guess limit Exceeded", c.evaluateGuess("Equilateral,Large,No,34,18,34"));
	}
	@Test
	public void test_threewise232() {
	System.out.println("======================== Test Case threewise232 ========================\n");
	System.out.println("Input: [Equilateral,Small,Yes,2,2]\n");
	System.out.println("Expected Output: [No: Suggestion=Circle]\n");
	assertEquals("Check ", "No: Suggestion=Circle", c.evaluateGuess("Equilateral,Small,Yes,2,2"));
	}

	
	@Test
	public void test_170() {
		String actualOutput = c.evaluateGuess("Scalene,Large,Yes,100,300,100");
		assertEquals("No", actualOutput);
	}
	
	@Test
	public void test_171() {
		String actualOutput = c.evaluateGuess("Rectangle,Large,Yes,100,100,200,200");
		assertEquals("No", actualOutput);
	}
	
	@Test
	public void test001() {
		Assert.assertEquals(null, c.evaluateGuess("Scalene,Small,No,2982,3210,353"));
	}

	@Test
	public void test002() {
		Assert.assertEquals(null, c.evaluateGuess("Equilateral,Diamond,,-74,3922,1065,2139"));
	}

	@Test
	public void test003() {
		Assert.assertEquals(null, c.evaluateGuess("Isosceles,,Yes,3828,1690,3673.89447701811"));
	}

	@Test
	public void test004() {
		Assert.assertEquals(null, c.evaluateGuess(",Large,,145,-51"));
	}

	@Test
	public void test005() {
		Assert.assertEquals(null, c.evaluateGuess("Scalene,,Yes,2611,-49"));
	}

	@Test
	public void test006() {
		Assert.assertEquals(null, c.evaluateGuess("Equilateral,Large,No,2649,1919,3017,6221"));
	}

	@Test
	public void test007() {
		Assert.assertEquals(null, c.evaluateGuess("Ellipse,Small,13223.424513,##@$@#$%#%"));
	}

	@Test
	public void test008() {
		Assert.assertEquals(null, c.evaluateGuess("Rectangle,Large,Diamond,1053,2199,1969,6923"));
	}

	@Test
	public void test009() {
		Assert.assertEquals(null, c.evaluateGuess(",13223.424513,,4396"));
	}

	@Test
	public void test010() {
		Assert.assertEquals(null, c.evaluateGuess("Line,13223.424513,No,2197,13223.424513"));
	}

	@Test
	public void test011() {
		Assert.assertEquals(null, c.evaluateGuess("Scalene,,Diamond,1138,1189,914"));
	}

	@Test
	public void test012() {
		Assert.assertEquals(null, c.evaluateGuess("13223.424513,Small,No,3301,##@$@#$%#%,783"));
	}

	@Test
	public void test013() {
		Assert.assertEquals(null, c.evaluateGuess("Circle,Large,No,282.894925453186"));
	}

	@Test
	public void test014() {
		Assert.assertEquals(null, c.evaluateGuess("Diamond,Diamond,No,701"));
	}

	@Test
	public void test015() {
		Assert.assertEquals(null, c.evaluateGuess("Line,Large,##@$@#$%#%,1711,2340"));
	}

	@Test
	public void test016() {
		Assert.assertEquals(null, c.evaluateGuess("Scalene,Large,Diamond,3785,3638,11,3376.88090994809"));
	}

	@Test
	public void test017() {
		Assert.assertEquals(null, c.evaluateGuess("Square,##@$@#$%#%,Diamond,3295.37204966898,3857,882"));
	}

	@Test
	public void test018() {
		Assert.assertEquals(null, c.evaluateGuess("Square,##@$@#$%#%,Yes,4071,2839,2947,9492"));
	}

	@Test
	public void test019() {
		Assert.assertEquals(null, c.evaluateGuess("Isosceles,Large,Yes,1130,74,-83,805"));
	}

	@Test
	public void test020() {
		Assert.assertEquals(null, c.evaluateGuess("Isosceles,Diamond,Diamond,1383,Diamond,3719"));
	}

	@Test
	public void test021() {
		Assert.assertEquals(null, c.evaluateGuess("Square,13223.424513,Diamond,2652,3965,1942"));
	}

	@Test
	public void test022() {
		Assert.assertEquals(null, c.evaluateGuess("Diamond,13223.424513,Yes,1526.5451123852"));
	}

	@Test
	public void test023() {
		Assert.assertEquals(null, c.evaluateGuess("Isosceles,Small,,9281,899"));
	}

	@Test
	public void test024() {
		Assert.assertEquals(null, c.evaluateGuess("13223.424513,Small,,2976.1195819737,3304,2292"));
	}

	@Test
	public void test025() {
		Assert.assertEquals(null, c.evaluateGuess("13223.424513,Large,No,3595,7584,2964"));
	}

	@Test
	public void test026() {
		Assert.assertEquals(null, c.evaluateGuess("Ellipse,13223.424513,No,187,3078,1802"));
	}

	@Test
	public void test027() {
		Assert.assertEquals(null, c.evaluateGuess("Scalene,Diamond,No,3238,##@$@#$%#%"));
	}

	@Test
	public void test028() {
		Assert.assertEquals(null, c.evaluateGuess("Scalene,Large,No,927,-62,3926"));
	}

	@Test
	public void test029() {
		Assert.assertEquals(null, c.evaluateGuess("Scalene,Large,,1340.76984572959,3444,1674"));
	}

	@Test
	public void test030() {
		Assert.assertEquals(null, c.evaluateGuess("Circle,Small,Yes,2670"));
	}

	@Test
	public void test031() {
		Assert.assertEquals(null, c.evaluateGuess("Scalene,Small,No,2464,1909,13223.424513"));
	}

	@Test
	public void test032() {
		Assert.assertEquals(null, c.evaluateGuess("Square,Large,,1277,3886,-46"));
	}

	@Test
	public void test033() {
		Assert.assertEquals(null, c.evaluateGuess(",,Diamond,13223.424513"));
	}

	@Test
	public void test034() {
		Assert.assertEquals(null, c.evaluateGuess("13223.424513,,No,1527,-67,2509,839"));
	}

	@Test
	public void test035() {
		Assert.assertEquals(null, c.evaluateGuess("Ellipse,13223.424513,Diamond,5039,3607,750"));
	}

	@Test
	public void test036() {
		Assert.assertEquals(null, c.evaluateGuess("Scalene,,No,578.651299834555,1613,3732,80"));
	}

	@Test
	public void test037() {
		Assert.assertEquals(null, c.evaluateGuess("Square,Diamond,Yes,1602,8107,2255"));
	}

	@Test
	public void test038() {
		Assert.assertEquals(null, c.evaluateGuess("Diamond,Small,Diamond,3203,2820,3537"));
	}

	@Test
	public void test039() {
		Assert.assertEquals(null, c.evaluateGuess("Equilateral,Diamond,Diamond,2571,511,-36"));
	}

	@Test
	public void test040() {
		Assert.assertEquals(null, c.evaluateGuess("Isosceles,Large,,3086,1221,,1994"));
	}
	
	@org.junit.Test
	public void test0337() {
		Assert.assertEquals("No", c.evaluateGuess("Circle,Small,Yes,5,4"));		
	}
	
	@org.junit.Test
	public void test0338() {
		Assert.assertEquals("No", c.evaluateGuess("Ellipse,Small,Yes,5,5"));		
	}
	
	@org.junit.Test
	public void test0339() {
		Assert.assertEquals("No", c.evaluateGuess("Ellipse,Small,Yes,0,0"));		
	}
	
	@org.junit.Test
	public void test0340() {
		Assert.assertEquals("No", c.evaluateGuess("Circle,Small,Yes,0,1"));		
	}
}
